Classes
class	BlendFilterContentsTest

struct	BlendModeSelection

struct	CheckSameSignature

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

struct	ColorBlendTestData

class	CommandBufferMock

class	CompareFunctionUIData

class	ContextMock

class	ContextSpy

struct	CVTest

struct	Foo

class	GaussianBlurFilterContentsTest

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

class	GoldenTests

struct	MaskBlurTestConfig

class	MatrixFilterContentsTest

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	MockFence

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

class	MockImpellerContext

class	MockRenderPass

class	MockSampler

class	MockSamplerLibrary

class	MockTexture

class	MockVulkanContextBuilder

class	NoopCommandQueue

class	RendererDartTest

struct	RWFoo

class	Screenshot

class	Screenshotter

class	TestAllocator

class	TestPassDelegate

struct	TextRenderOptions

class	VulkanScreenshotter

class	WorkingDirectory

Typedefs
using	AiksTest = AiksPlayground

using	AiksCanvasTest = ::testing::Test

using	DisplayListTest = DlPlayground

using	EntityTest = EntityPlayground

using	HostBufferTest = EntityPlayground

using	EntityPassTargetTest = EntityPlayground

using	RenderTargetCacheTest = EntityPlayground

using	DriverInfoVKTest = PlaygroundTest

using	RendererTest = PlaygroundTest

using	BlitPassTest = PlaygroundTest

using	ComputeTest = ComputePlaygroundTest

using	DeviceBufferTest = Playground

using	RuntimeStageTest = RuntimeStagePlayground

using	TypographerTest = PlaygroundTest

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

	TEST_P (AiksTest, BlendModePlusAlphaColorFilterWideGamut)

static BlendModeSelection	GetBlendModeSelection ()

	TEST_P (AiksTest, ColorWheel)

	TEST_P (AiksTest, ForegroundBlendSubpassCollapseOptimization)

	TEST_P (AiksTest, ClearBlend)

static Picture	BlendModeTest (Vector2 content_scale, BlendMode blend_mode, const std::shared_ptr< Image > &src_image, const std::shared_ptr< Image > &dst_image, Scalar src_alpha)

	TEST_P (AiksTest, CanDrawPaintMultipleTimesInteractive)

	TEST_P (AiksTest, ForegroundPipelineBlendAppliesTransformCorrectly)

	TEST_P (AiksTest, ForegroundAdvancedBlendAppliesTransformCorrectly)

	TEST_P (AiksTest, FramebufferAdvancedBlendCoverage)

	TEST_P (AiksTest, CanRenderMaskBlurHugeSigma)

	TEST_P (AiksTest, CanRenderForegroundBlendWithMaskBlur)

	TEST_P (AiksTest, CanRenderForegroundAdvancedBlendWithMaskBlur)

	TEST_P (AiksTest, CanRenderBackdropBlurInteractive)

	TEST_P (AiksTest, CanRenderBackdropBlur)

	TEST_P (AiksTest, CanRenderBackdropBlurHugeSigma)

	TEST_P (AiksTest, CanRenderClippedBlur)

	TEST_P (AiksTest, ClippedBlurFilterRendersCorrectlyInteractive)

	TEST_P (AiksTest, ClippedBlurFilterRendersCorrectly)

	TEST_P (AiksTest, ClearBlendWithBlur)

	TEST_P (AiksTest, BlurHasNoEdge)

	TEST_P (AiksTest, BlurredRectangleWithShader)

	TEST_P (AiksTest, MaskBlurWithZeroSigmaIsSkipped)

static Picture	MaskBlurVariantTest (const AiksTest &test_context, const MaskBlurTestConfig &config)

	TEST_P (AiksTest, GaussianBlurAtPeripheryVertical)

	TEST_P (AiksTest, GaussianBlurAtPeripheryHorizontal)

	TEST_P (AiksTest, GaussianBlurWithoutDecalSupport)

	TEST_P (AiksTest, GaussianBlurOneDimension)

	TEST_P (AiksTest, GaussianBlurRotatedAndClipped)

	TEST_P (AiksTest, GaussianBlurScaledAndClipped)

	TEST_P (AiksTest, GaussianBlurRotatedAndClippedInteractive)

	TEST_P (AiksTest, GaussianBlurRotatedNonUniform)

	TEST_P (AiksTest, GaussianBlurSolidColorTinyMipMap)

	TEST_P (AiksTest, GaussianBlurBackdropTinyMipMap)

	TEST_P (AiksTest, GaussianBlurAnimatedBackdrop)

	TEST_P (AiksTest, GaussianBlurStyleInnerGradient)

	TEST_P (AiksTest, GaussianBlurStyleSolidGradient)

	TEST_P (AiksTest, GaussianBlurStyleOuterGradient)

	TEST_P (AiksTest, GaussianBlurStyleInner)

	TEST_P (AiksTest, GaussianBlurStyleOuter)

	TEST_P (AiksTest, GaussianBlurStyleSolid)

	TEST_P (AiksTest, MaskBlurTexture)

	TEST_P (AiksTest, GuassianBlurUpdatesMipmapContents)

	TEST_P (AiksTest, GaussianBlurSetsMipCountOnPass)

	TEST_P (AiksTest, GaussianBlurAllocatesCorrectMipCountRenderTarget)

	TEST_P (AiksTest, GaussianBlurMipMapNestedLayer)

	TEST_P (AiksTest, GaussianBlurMipMapImageFilter)

	TEST_P (AiksTest, GaussianBlurMipMapSolidColor)

	TEST_P (AiksTest, MaskBlurDoesntStretchContents)

	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 (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, 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, CanRenderOverlappingMultiContourPath)

	INSTANTIATE_PLAYGROUND_SUITE (AiksTest)

	TEST_P (AiksTest, CanvasCTMCanBeUpdated)

	TEST_P (AiksTest, CanvasCanPushPopCTM)

	TEST_P (AiksTest, CanRenderColoredRect)

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

	TEST_P (AiksTest, CanSaveLayerStandalone)

	TEST_P (AiksTest, CanRenderDifferentShapesWithSameColorSource)

	TEST_P (AiksTest, CanPictureConvertToImage)

	TEST_P (AiksTest, CanEmptyPictureConvertToImage)

	TEST_P (AiksTest, CoordinateConversionsAreCorrect)

	TEST_P (AiksTest, CanPerformFullScreenMSAA)

	TEST_P (AiksTest, CanPerformSkew)

	TEST_P (AiksTest, CanPerformSaveLayerWithBounds)

	TEST_P (AiksTest, CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated)

	TEST_P (AiksTest, CanRenderRoundedRectWithNonUniformRadii)

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

bool	RenderTextInCanvasSTB (const std::shared_ptr< Context > &context, Canvas &canvas, const std::string &text, const std::string &font_fixture, TextRenderOptions options={})

	TEST_P (AiksTest, CanRenderTextFrame)

	TEST_P (AiksTest, CanRenderStrokedTextFrame)

	TEST_P (AiksTest, CanRenderTextFrameWithHalfScaling)

	TEST_P (AiksTest, CanRenderTextFrameWithFractionScaling)

	TEST_P (AiksTest, CanRenderTextFrameSTB)

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

	TEST_P (AiksTest, CanDrawPaintMultipleTimes)

	TEST_P (AiksTest, FormatWideGamut)

	TEST_P (AiksTest, FormatSRGB)

	TEST_P (AiksTest, TransformMultipliesCorrectly)

	TEST_P (AiksTest, FilledCirclesRenderCorrectly)

	TEST_P (AiksTest, StrokedCirclesRenderCorrectly)

	TEST_P (AiksTest, FilledEllipsesRenderCorrectly)

	TEST_P (AiksTest, FilledRoundRectsRenderCorrectly)

	TEST_P (AiksTest, SolidColorCirclesOvalsRRectsMaskBlurCorrectly)

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

	TEST_P (AiksTest, DrawPaintAbsorbsClears)

	TEST_P (AiksTest, ParentSaveLayerCreatesRenderPassWhenChildBackdropFilterIsPresent)

	TEST_P (AiksTest, DrawRectAbsorbsClears)

	TEST_P (AiksTest, DrawRectAbsorbsClearsNegativeRRect)

	TEST_P (AiksTest, DrawRectAbsorbsClearsNegativeRotation)

	TEST_P (AiksTest, DrawRectAbsorbsClearsNegative)

	TEST_P (AiksTest, ClipRectElidesNoOpClips)

	TEST_P (AiksTest, ClearColorOptimizationDoesNotApplyForBackdropFilters)

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

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

	TEST_P (AiksTest, CanRenderDestructiveSaveLayer)

	TEST_P (AiksTest, CanRenderClippedRuntimeEffects)

	TEST_P (AiksTest, DrawPaintTransformsBounds)

	TEST_P (AiksTest, CanDrawPoints)

	TEST_P (AiksTest, CanDrawPointsWithTextureMap)

	TEST_P (AiksTest, TextForegroundShaderWithTransform)

	TEST_P (AiksTest, MatrixSaveLayerFilter)

	TEST_P (AiksTest, MatrixBackdropFilter)

	TEST_P (AiksTest, SolidColorApplyColorFilter)

	TEST_P (AiksTest, DrawScaledTextWithPerspectiveNoSaveLayer)

	TEST_P (AiksTest, DrawScaledTextWithPerspectiveSaveLayer)

	TEST_P (AiksTest, PipelineBlendSingleParameter)

	TEST_P (AiksTest, ReleasesTextureOnTeardown)

	TEST_P (AiksTest, MatrixImageFilterMagnify)

	TEST_P (AiksTest, MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen)

	TEST_P (AiksTest, MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen)

	TEST_P (AiksTest, ClearColorOptimizationWhenSubpassIsBiggerThanParentPass)

	TEST_P (AiksTest, EmptySaveLayerIgnoresPaint)

	TEST_P (AiksTest, EmptySaveLayerRendersWithClear)

	TEST_P (AiksTest, SubpassWithClearColorOptimization)

	TEST_P (AiksTest, ImageColorSourceEffectTransform)

	TEST_P (AiksTest, CorrectClipDepthAssignedToEntities)

	TEST_P (AiksTest, CanDrawPerspectiveTransformWithClips)

	TEST_P (AiksTest, CanRenderClippedBackdropFilter)

	TEST_P (AiksTest, MipmapGenerationWorksCorrectly)

	TEST_P (AiksTest, StrokedPathWithMoveToThenCloseDrawnCorrectly)

	TEST_P (AiksTest, CanRenderTextWithLargePerspectiveTransform)

	TEST_P (AiksTest, SetContentsWithRegion)

	TEST (AiksCanvasTest, EmptyCullRect)

	TEST (AiksCanvasTest, InitialCullRect)

	TEST (AiksCanvasTest, TranslatedCullRect)

	TEST (AiksCanvasTest, ScaledCullRect)

	TEST (AiksCanvasTest, RectClipIntersectAgainstEmptyCullRect)

	TEST (AiksCanvasTest, RectClipDiffAgainstEmptyCullRect)

	TEST (AiksCanvasTest, RectClipIntersectAgainstCullRect)

	TEST (AiksCanvasTest, RectClipDiffAgainstNonCoveredCullRect)

	TEST (AiksCanvasTest, RectClipDiffAboveCullRect)

	TEST (AiksCanvasTest, RectClipDiffBelowCullRect)

	TEST (AiksCanvasTest, RectClipDiffLeftOfCullRect)

	TEST (AiksCanvasTest, RectClipDiffRightOfCullRect)

	TEST (AiksCanvasTest, RectClipDiffAgainstVCoveredCullRect)

	TEST (AiksCanvasTest, RectClipDiffAgainstHCoveredCullRect)

	TEST (AiksCanvasTest, RRectClipIntersectAgainstEmptyCullRect)

	TEST (AiksCanvasTest, RRectClipDiffAgainstEmptyCullRect)

	TEST (AiksCanvasTest, RRectClipIntersectAgainstCullRect)

	TEST (AiksCanvasTest, RRectClipDiffAgainstNonCoveredCullRect)

	TEST (AiksCanvasTest, RRectClipDiffAgainstVPartiallyCoveredCullRect)

	TEST (AiksCanvasTest, RRectClipDiffAgainstVFullyCoveredCullRect)

	TEST (AiksCanvasTest, RRectClipDiffAgainstHPartiallyCoveredCullRect)

	TEST (AiksCanvasTest, RRectClipDiffAgainstHFullyCoveredCullRect)

	TEST (AiksCanvasTest, PathClipIntersectAgainstEmptyCullRect)

	TEST (AiksCanvasTest, PathClipDiffAgainstEmptyCullRect)

	TEST (AiksCanvasTest, PathClipIntersectAgainstCullRect)

	TEST (AiksCanvasTest, PathClipDiffAgainstNonCoveredCullRect)

	TEST (AiksCanvasTest, PathClipDiffAgainstFullyCoveredCullRect)

	TEST (AiksCanvasTest, DisableLocalBoundsRectForFilteredSaveLayers)

	TEST (ThreadTest, CanCreateMutex)

	TEST (ThreadTest, CanCreateMutexLock)

	TEST (ThreadTest, CanCreateRWMutex)

	TEST (ThreadTest, CanCreateRWMutexLock)

	TEST (StringsTest, CanSPrintF)

	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_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, CanRenderNestedClips)

	TEST_P (AiksTest, CanRenderDifferenceClips)

	TEST_P (AiksTest, CanRenderWithContiguousClipRestores)

	TEST_P (AiksTest, ClipsUseCurrentTransform)

	TEST_P (AiksTest, CanRenderLinearGradientClamp)

	TEST_P (AiksTest, CanRenderLinearGradientRepeat)

	TEST_P (AiksTest, CanRenderLinearGradientMirror)

	TEST_P (AiksTest, CanRenderLinearGradientDecal)

	TEST_P (AiksTest, CanRenderLinearGradientDecalWithColorFilter)

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

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

	TEST_P (DisplayListTest, CanDrawNinePatchImageCenterWidthBiggerThanDest)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCenterHeightBiggerThanDest)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCenterBiggerThanDest)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCornersScaledDown)

	TEST_P (DisplayListTest, NinePatchImagePrecision)

	TEST_P (DisplayListTest, CanDrawPoints)

	TEST_P (DisplayListTest, CanDrawZeroLengthLine)

	TEST_P (DisplayListTest, CanDrawShadow)

	TEST_P (DisplayListTest, DispatcherDoesNotCullPerspectiveTransformedChildDisplayLists)

	TEST_P (DisplayListTest, TransparentShadowProducesCorrectColor)

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

	TEST_P (DisplayListTest, DrawVerticesBlendModes)

template<typename Contents >
static std::optional< Rect >	GetCoverageOfFirstEntity (const Picture &picture)

	TEST (DisplayListTest, RRectBoundsComputation)

	TEST (DisplayListTest, CircleBoundsComputation)

	TEST_P (DisplayListTest, DrawPaintIgnoresMaskFilter)

	TEST_P (DisplayListTest, DrawMaskBlursThatMightUseSaveLayers)

	TEST (SkiaConversionsTest, SkPointToPoint)

	TEST (SkiaConversionsTest, SkPointToSize)

	TEST (SkiaConversionsTest, ToColor)

	TEST (SkiaConversionsTest, GradientStopConversion)

	TEST (SkiaConversionsTest, GradientMissing0)

	TEST (SkiaConversionsTest, GradientMissingLastValue)

	TEST (SkiaConversionsTest, GradientStopGreaterThan1)

	TEST (SkiaConversionsTest, GradientConversionNonMonotonic)

	TEST (SkiaConversionsTest, IsNearlySimpleRRect)

	TEST_P (EntityTest, ClipContentsOptimizesFullScreenIntersectClips)

	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, 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 (FilterInputTest, CanSetLocalTransformForTexture)

	TEST (FilterInputTest, IsLeaf)

	TEST (FilterInputTest, SetCoverageInputs)

	INSTANTIATE_PLAYGROUND_SUITE (MatrixFilterContentsTest)

	TEST (MatrixFilterContentsTest, Create)

	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 (HostBufferTest)

	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_P (EntityTest, TiledTextureContentsRendersWithCorrectPipeline)

	TEST_P (EntityTest, TiledTextureContentsRendersWithCorrectPipelineExternalOES)

	TEST_P (EntityPassTargetTest, SwapWithMSAATexture)

	TEST_P (EntityPassTargetTest, SwapWithMSAAImplicitResolve)

	TEST (EntityPassClipStackTest, CanPushAndPopEntities)

	TEST (EntityPassClipStackTest, CanPopEntitiesSafely)

	TEST (EntityPassClipStackTest, CanAppendNoChange)

	TEST (EntityPassClipStackTest, AppendCoverageNoChange)

	TEST (EntityPassClipStackTest, AppendAndRestoreClipCoverage)

	TEST (EntityPassClipStackTest, UnbalancedRestore)

	TEST (EntityPassClipStackTest, ClipAndRestoreWithSubpasses)

	TEST_P (EntityTest, CanCreateEntity)

auto	CreatePassWithRectPath (Rect rect, std::optional< Rect > bounds_hint, ContentBoundsPromise bounds_promise=ContentBoundsPromise::kUnknown, bool collapse=false)

	TEST_P (EntityTest, EntityPassRespectsUntrustedSubpassBoundsLimit)

	TEST_P (EntityTest, EntityPassTrustsSnugSubpassBoundsLimit)

	TEST_P (EntityTest, EntityPassCanMergeSubpassIntoParent)

	TEST_P (EntityTest, EntityPassCoverageRespectsCoverageLimit)

	TEST_P (EntityTest, FilterCoverageRespectsCropRect)

	TEST_P (EntityTest, CanDrawRect)

	TEST_P (EntityTest, CanDrawRRect)

	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_P (EntityTest, SolidStrokeCoverageIsCorrect)

	TEST_P (EntityTest, BorderMaskBlurCoverageIsCorrect)

	TEST_P (EntityTest, SolidFillCoverageIsCorrect)

	TEST_P (EntityTest, SolidFillShouldRenderIsCorrect)

	TEST_P (EntityTest, DoesNotCullEntitiesByDefault)

	TEST_P (EntityTest, ClipContentsShouldRenderIsCorrect)

	TEST_P (EntityTest, ClipContentsGetClipCoverageIsCorrect)

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

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

	TEST_P (EntityTest, SpecializationConstantsAreAppliedToVariants)

	TEST_P (EntityTest, DecalSpecializationAppliedToMorphologyFilter)

	TEST_P (EntityTest, ContentContextOptionsHasReasonableHashFunctions)

	TEST_P (EntityTest, FillPathGeometryGetPositionBufferReturnsExpectedMode)

	TEST_P (EntityTest, FailOnValidationError)

	TEST_P (EntityTest, CanComputeGeometryForEmptyPathsWithoutCrashing)

	TEST_P (EntityTest, CanRenderEmptyPathsWithoutCrashing)

	TEST (EntityGeometryTest, RectGeometryCoversArea)

	TEST (EntityGeometryTest, FillPathGeometryCoversArea)

	TEST (EntityGeometryTest, FillPathGeometryCoversAreaNoInnerRect)

	TEST (EntityGeometryTest, LineGeometryCoverage)

	TEST (EntityGeometryTest, RoundRectGeometryCoversArea)

	TEST (EntityGeometryTest, GeometryResultHasReasonableDefaults)

	TEST (EntityGeometryTest, AlphaCoverageStrokePaths)

	TEST_P (RenderTargetCacheTest, CachesUsedTexturesAcrossFrames)

	TEST_P (RenderTargetCacheTest, DoesNotPersistFailedAllocations)

	TEST_P (RenderTargetCacheTest, CachedTextureGetsNewAttachmentConfig)

	TEST_P (RenderTargetCacheTest, CreateWithEmptySize)

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

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

	TEST (MatrixTest, HasPerspective)

	TEST (MatrixTest, HasTranslation)

	TEST (MatrixTest, IsAligned2D)

	TEST (MatrixTest, IsAligned)

	TEST (MatrixTest, TransformHomogenous)

	TEST (PathTest, CubicPathComponentPolylineDoesNotIncludePointOne)

	TEST (PathTest, PathCreatePolyLineDoesNotDuplicatePoints)

	TEST (PathTest, PathBuilderSetsCorrectContourPropertiesForAddCommands)

	TEST (PathTest, PathCreatePolylineGeneratesCorrectContourData)

	TEST (PathTest, PolylineGetContourPointBoundsReturnsCorrectRanges)

	TEST (PathTest, PathAddRectPolylineHasCorrectContourData)

	TEST (PathTest, PathPolylineDuplicatesAreRemovedForSameContour)

	TEST (PathTest, PolylineBufferReuse)

	TEST (PathTest, PolylineFailsWithNullptrBuffer)

	TEST (PathTest, PathShifting)

	TEST (PathTest, PathBuilderWillComputeBounds)

	TEST (PathTest, PathHorizontalLine)

	TEST (PathTest, PathVerticalLine)

	TEST (PathTest, QuadradicPath)

	TEST (PathTest, CubicPath)

	TEST (PathTest, BoundingBoxCubic)

	TEST (PathTest, BoundingBoxOfCompositePathIsCorrect)

	TEST (PathTest, ExtremaOfCubicPathComponentIsCorrect)

	TEST (PathTest, PathGetBoundingBoxForCubicWithNoDerivativeRootsIsCorrect)

	TEST (PathTest, EmptyPath)

	TEST (PathTest, SimplePath)

	TEST (PathTest, RepeatCloseDoesNotAddNewLines)

	TEST (PathTest, CloseAfterMoveDoesNotAddNewLines)

	TEST (PathTest, CloseAtOriginDoesNotAddNewLineSegment)

	TEST (PathTest, CanBeCloned)

	TEST (PathTest, PathBuilderDoesNotMutateCopiedPaths)

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

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

	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_F (GoldenTests, ConicalGradient)

	TEST (CapabilitiesGLES, CanInitializeWithDefaults)

	TEST (CapabilitiesGLES, SupportsDecalSamplerAddressMode)

	TEST (CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES)

	TEST (CapabilitiesGLES, SupportsFramebufferFetch)

	TEST (FormatsGLES, CanFormatFramebufferErrorMessage)

void	RecordGLCall (const char *name)

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)

	TEST (MockGLES, CanInitialize)

	TEST (MockGLES, CapturesPushAndPopDebugGroup)

	TEST (MockGLES, CanCallUnmockedFunction)

	TEST (ProcTableGLES, ResolvesCorrectClearDepthProcOnES)

	TEST (ProcTableGLES, ResolvesCorrectClearDepthProcOnDesktopGL)

	TEST (SpecConstant, CanCreateShaderWithSpecializationConstant)

	TEST (SpecConstant, CanCreateShaderWithSpecializationConstantMultipleValues)

	TEST (TextureMTL, CreateFromDrawable)

	TEST (AllocatorVKTest, ToVKImageUsageFlags)

	TEST (AllocatorVKTest, MemoryTypeSelectionSingleHeap)

	TEST (AllocatorVKTest, MemoryTypeSelectionTwoHeap)

	TEST (CommandEncoderVKTest, DeleteEncoderAfterThreadDies)

	TEST (CommandEncoderVKTest, CleanupAfterSubmit)

	TEST (CommandPoolRecyclerVKTest, GetsACommandPoolPerThread)

	TEST (CommandPoolRecyclerVKTest, GetsTheSameCommandPoolOnSameThread)

	TEST (CommandPoolRecyclerVKTest, ReclaimMakesCommandPoolAvailable)

	TEST (CommandPoolRecyclerVKTest, CommandBuffersAreRecycled)

	TEST (ContextVKTest, CommonHardwareConcurrencyConfigurations)

	TEST (ContextVKTest, DeletesCommandPools)

	TEST (ContextVKTest, DeletesCommandPoolsOnAllThreads)

	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 (DescriptorPoolRecyclerVKTest, GetDescriptorPoolRecyclerCreatesNewPools)

	TEST (DescriptorPoolRecyclerVKTest, ReclaimMakesDescriptorPoolAvailable)

	TEST (DescriptorPoolRecyclerVKTest, ReclaimDropsDescriptorPoolIfSizeIsExceeded)

	INSTANTIATE_VULKAN_PLAYGROUND_SUITE (DriverInfoVKTest)

	TEST_P (DriverInfoVKTest, CanQueryDriverInfo)

	TEST_P (DriverInfoVKTest, CanDumpToLog)

	TEST (FenceWaiterVKTest, IgnoresNullFence)

	TEST (FenceWaiterVKTest, IgnoresNullCallback)

	TEST (FenceWaiterVKTest, ExecutesFenceCallback)

	TEST (FenceWaiterVKTest, ExecutesFenceCallbackX2)

	TEST (FenceWaiterVKTest, ExecutesNewFenceThenOldFence)

	TEST (FenceWaiterVKTest, AddFenceDoesNothingIfTerminating)

	TEST (FenceWaiterVKTest, InProgressFencesStillWaitIfTerminated)

	TEST (RenderPassBuilder, CreatesRenderPassWithNoDepthStencil)

	TEST (RenderPassBuilder, CreatesRenderPassWithCombinedDepthStencil)

	TEST (RenderPassBuilder, CreatesRenderPassWithOnlyStencil)

	TEST (RenderPassBuilder, CreatesMSAAResolveWithCorrectStore)

	TEST_P (RendererTest, CachesRenderPassAndFramebuffer)

	TEST (ResourceManagerVKTest, CreatesANewInstance)

	TEST (ResourceManagerVKTest, ReclaimMovesAResourceAndDestroysIt)

	TEST (ResourceManagerVKTest, TerminatesWhenOutOfScope)

	TEST (ResourceManagerVKTest, IsThreadSafe)

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

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

	TEST (MockVulkanContextTest, IsThreadSafe)

	TEST (MockVulkanContextTest, DefaultFenceAlwaysReportsSuccess)

	TEST (MockVulkanContextTest, MockedFenceReportsStatus)

vk::UniqueSurfaceKHR	CreateSurface (const ContextVK &context)

	TEST (SwapchainTest, CanCreateSwapchain)

	TEST (SwapchainTest, RecreateSwapchainWhenSizeChanges)

	TEST (SwapchainTest, CachesRenderPassOnSwapchainImage)

	INSTANTIATE_PLAYGROUND_SUITE (BlitPassTest)

	TEST_P (BlitPassTest, BlitAcrossDifferentPixelFormatsFails)

	TEST_P (BlitPassTest, BlitAcrossDifferentSampleCountsFails)

	TEST_P (BlitPassTest, BlitPassesForMatchingFormats)

	TEST_P (BlitPassTest, ChecksInvalidSliceParameters)

	TEST_P (BlitPassTest, CanBlitSmallRegionToUninitializedTexture)

	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)

	TEST (CapabilitiesTest, DefaultColorFormat)

	TEST (CapabilitiesTest, DefaultStencilFormat)

	TEST (CapabilitiesTest, DefaultDepthStencilFormat)

	TEST (CapabilitiesTest, DefaultGlyphAtlasFormat)

	INSTANTIATE_COMPUTE_SUITE (ComputeTest)

	TEST_P (ComputeTest, CapabilitiesReportSupport)

	TEST_P (ComputeTest, CanCreateComputePass)

	TEST_P (ComputeTest, CanComputePrefixSum)

	TEST_P (ComputeTest, 1DThreadgroupSizingIsCorrect)

	TEST_P (ComputeTest, CanComputePrefixSumLargeInteractive)

	TEST_P (ComputeTest, MultiStageInputAndOutput)

	TEST_P (ComputeTest, CanCompute1DimensionalData)

	TEST_P (ComputeTest, ReturnsEarlyWhenAnyGridDimensionIsZero)

	TEST (PipelineDescriptorTest, PrimitiveTypeHashEquality)

	TEST (PoolTest, Simple)

	TEST (PoolTest, Overload)

static void	InstantiateTestShaderLibrary (Context::BackendType backend_type)

	INSTANTIATE_PLAYGROUND_SUITE (RendererDartTest)

	TEST_P (RendererDartTest, CanRunDartInPlaygroundFrame)

	TEST_P (RendererDartTest, CanInstantiateFlutterGPUContext)

	TEST_P (RendererDartTest, CanCreateShaderLibrary)

	TEST_P (RendererDartTest, CanReflectUniformStructs)

	TEST_P (RendererDartTest, UniformBindFailsForInvalidHostBufferOffset)

	TEST_P (RendererDartTest, CanCreateRenderPassAndSubmit)

	TEST_P (RendererTest, CanCreateBoxPrimitive)

	TEST_P (RendererTest, BabysFirstTriangle)

	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 (const std::shared_ptr< Context > &context)

	TEST_P (RendererTest, CanSepiaToneWithSubpasses)

	TEST_P (RendererTest, CanSepiaToneThenSwizzleWithSubpasses)

	INSTANTIATE_PLAYGROUND_SUITE (RuntimeStageTest)

	TEST_P (RuntimeStageTest, CanReadValidBlob)

	TEST_P (RuntimeStageTest, CanRejectInvalidBlob)

	TEST_P (RuntimeStageTest, CanReadUniforms)

	TEST_P (RuntimeStageTest, CanReadUniformsSamplerBeforeUBO)

	TEST_P (RuntimeStageTest, CanReadUniformsSamplerAfterUBO)

	TEST_P (RuntimeStageTest, CanRegisterStage)

	TEST_P (RuntimeStageTest, CanCreatePipelineFromRuntimeStage)

	TEST_P (RuntimeStageTest, ContainsExpectedShaderTypes)

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

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

	TEST (ShaderArchiveTest, CanReadAndWriteBlobs)

	TEST (TessellatorTest, TessellatorBuilderReturnsCorrectResultStatus)

	TEST (TessellatorTest, TessellateConvex)

	TEST (TessellatorTest, TessellateConvexUnclosedPath)

	TEST (TessellatorTest, CircleVertexCounts)

	TEST (TessellatorTest, FilledCircleTessellationVertices)

	TEST (TessellatorTest, StrokedCircleTessellationVertices)

	TEST (TessellatorTest, RoundCapLineTessellationVertices)

	TEST (TessellatorTest, FilledEllipseTessellationVertices)

	TEST (TessellatorTest, FilledRoundRectTessellationVertices)

	TEST (TessellatorTest, EarlyReturnEmptyConvexShape)

	TEST (TessellatorTest, ChecksConcurrentPolylineUsage)

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

static std::shared_ptr< GlyphAtlas >	CreateGlyphAtlas (Context &context, const TypographerContext *typographer_context, HostBuffer &host_buffer, GlyphAtlas::Type type, Scalar scale, 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, RectanglePackerAddsNonoverlapingRectangles)

	TEST (TypographerTest, RectanglePackerFillsRows)

	TEST_P (TypographerTest, GlyphAtlasTextureWillGrowTilMaxTextureSize)

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

static constexpr std::string_view	kFontFixture

std::vector< Point >	golden_cubic_and_quad_points

static std::mutex	g_test_lock

static std::weak_ptr< MockGLES >	g_mock_gles

static ProcTableGLES::Resolver	g_resolver

static std::vector< const unsigned char * >	g_extensions

static const unsigned char *	g_version

auto const	kMockVendor = (unsigned char*)"MockGLES"

const auto	kMockShadingLanguageVersion = (unsigned char*)"GLSL ES 1.0"

auto const	kExtensions

const ProcTableGLES::Resolver	kMockResolverGLES

Typedef Documentation

◆ AiksCanvasTest

using impeller::testing::AiksCanvasTest = typedef ::testing::Test

Definition at line 16 of file canvas_unittests.cc.

◆ AiksTest

using impeller::testing::AiksTest = typedef AiksPlayground

Definition at line 17 of file aiks_unittests.h.

◆ BlitPassTest

using impeller::testing::BlitPassTest = typedef PlaygroundTest

Definition at line 16 of file blit_pass_unittests.cc.

◆ ComputeTest

using impeller::testing::ComputeTest = typedef ComputePlaygroundTest

Definition at line 21 of file compute_unittests.cc.

◆ 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 46 of file dl_unittests.cc.

◆ DriverInfoVKTest

using impeller::testing::DriverInfoVKTest = typedef PlaygroundTest

Definition at line 11 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 21 of file clip_contents_unittests.cc.

◆ HostBufferTest

using impeller::testing::HostBufferTest = typedef EntityPlayground

Definition at line 12 of file host_buffer_unittests.cc.

◆ RendererTest

typedef PlaygroundTest impeller::testing::RendererTest

Definition at line 14 of file render_pass_cache_unittests.cc.

◆ RenderTargetCacheTest

using impeller::testing::RenderTargetCacheTest = typedef EntityPlayground

Definition at line 19 of file render_target_cache_unittests.cc.

◆ RuntimeStageTest

using impeller::testing::RuntimeStageTest = typedef RuntimeStagePlayground

Definition at line 26 of file runtime_stage_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 Picture impeller::testing::BlendModeTest	(	Vector2	content_scale,
		BlendMode	blend_mode,
		const std::shared_ptr< Image > &	src_image,
		const std::shared_ptr< Image > &	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 368 of file aiks_blend_unittests.cc.

                                               {
  if (AiksTest::ImGuiBegin("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)});
 
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Black()});
  // TODO(bdero): Why does this cause the left image to double scale on high DPI
  //              displays.
  // canvas.Scale(content_scale);
 
  //----------------------------------------------------------------------------
  /// 1. Save layer blending (top squares).
  ///
 
  canvas.Save();
  for (const auto& color : source_colors) {
    canvas.Save();
    {
      canvas.ClipRect(Rect::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.
      canvas.SaveLayer({});
      {
        canvas.DrawPaint({.color = destination_color});
        // Draw the source color in an offscreen pass and blend it to the parent
        // pass.
        canvas.SaveLayer({.blend_mode = blend_mode});
        {  //
          canvas.DrawRect(Rect::MakeXYWH(25, 25, 100, 100), {.color = color});
        }
        canvas.Restore();
      }
      canvas.Restore();
    }
    canvas.Restore();
    canvas.Translate(Vector2(100, 0));
  }
  canvas.RestoreToCount(0);
 
  //----------------------------------------------------------------------------
  /// 2. CPU blend modes (bottom squares).
  ///
 
  canvas.Save();
  canvas.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.
  canvas.SaveLayer({});
  for (const auto& color : source_colors) {
    // Simply write the CPU blended color to the pass.
    canvas.DrawRect(Rect::MakeXYWH(25, 25, 100, 100),
                    {.color = destination_color.Blend(color, blend_mode),
                     .blend_mode = BlendMode::kSourceOver});
    canvas.Translate(Vector2(100, 0));
  }
  canvas.Restore();
  canvas.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
  ///
 
  canvas.Translate({0, 250});
 
  // Draw grid behind the images.
  canvas.DrawRect(Rect::MakeLTRB(0, 0, 800, 400),
                  {.color = Color::MakeRGBA8(41, 41, 41, 255)});
  Paint square_paint = {.color = Color::MakeRGBA8(15, 15, 15, 255)};
  for (int y = 0; y < 400 / 8; y++) {
    for (int x = 0; x < 800 / 16; x++) {
      canvas.DrawRect(Rect::MakeXYWH(x * 16 + (y % 2) * 8, y * 8, 8, 8),
                      square_paint);
    }
  }
 
  // Uploaded image source (left image).
  canvas.Save();
  canvas.SaveLayer({.blend_mode = BlendMode::kSourceOver});
  {
    canvas.DrawImage(dst_image, {0, 0},
                     {
                         .blend_mode = BlendMode::kSourceOver,
                     });
    canvas.DrawImage(src_image, {0, 0},
                     {
                         .color = Color::White().WithAlpha(src_alpha),
                         .blend_mode = blend_mode,
                     });
  }
  canvas.Restore();
  canvas.Restore();
 
  // Rendered image source (right image).
  canvas.Save();
  canvas.SaveLayer({.blend_mode = BlendMode::kSourceOver});
  {
    canvas.DrawImage(dst_image, {400, 0},
                     {.blend_mode = BlendMode::kSourceOver});
    canvas.SaveLayer({.color = Color::White().WithAlpha(src_alpha),
                      .blend_mode = blend_mode});
    {
      canvas.DrawImage(src_image, {400, 0},
                       {.blend_mode = BlendMode::kSourceOver});
    }
    canvas.Restore();
  }
  canvas.Restore();
  canvas.Restore();
 
  return canvas.EndRecordingAsPicture();
}

◆ CanRenderConicalGradientWithDithering()

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

static

Definition at line 167 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(SkRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

◆ CanRenderLinearGradientWithDithering()

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

static

Definition at line 104 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(SkRect::MakeXYWH(0, 0, 800, 500), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

◆ CanRenderRadialGradientWithDithering()

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

static

Definition at line 124 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(SkRect::MakeXYWH(0, 0, 1200, 1200), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

◆ CanRenderSweepGradientWithDithering()

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

static

Definition at line 144 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(SkRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

◆ CAPABILITY_TEST() [1/9]

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

◆ CAPABILITY_TEST() [2/9]

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

◆ CAPABILITY_TEST() [3/9]

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

◆ CAPABILITY_TEST() [4/9]

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

◆ CAPABILITY_TEST() [5/9]

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

◆ CAPABILITY_TEST() [6/9]

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

◆ CAPABILITY_TEST() [7/9]

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

◆ CAPABILITY_TEST() [8/9]

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

◆ CAPABILITY_TEST() [9/9]

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

◆ CompareFunctionUI()

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

static

Definition at line 1184 of file renderer_unittests.cc.

                                                        {
  static CompareFunctionUIData data;
  return data;
}

◆ CreateDefaultPipeline()

template<class VertexShader , class FragmentShader >

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

Definition at line 1376 of file renderer_unittests.cc.

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

◆ CreateGlyphAtlas() [1/2]

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

static

Definition at line 46 of file typographer_unittests.cc.

                                                  {
  FontGlyphMap font_glyph_map;
  size_t offset = 0;
  for (auto& frame : frames) {
    frame->CollectUniqueFontGlyphPairs(font_glyph_map, scale, {0, 0},
                                       properties[offset++]);
  }
  return typographer_context->CreateGlyphAtlas(context, type, host_buffer,
                                               atlas_context, font_glyph_map);
}

◆ CreateGlyphAtlas() [2/2]

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

static

Definition at line 32 of file typographer_unittests.cc.

                            {
  FontGlyphMap font_glyph_map;
  frame.CollectUniqueFontGlyphPairs(font_glyph_map, scale, {0, 0}, {});
  return typographer_context->CreateGlyphAtlas(context, type, host_buffer,
                                               atlas_context, font_glyph_map);
}

◆ CreateMappingFromString()

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

static

Definition at line 15 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) {});
}

◆ CreatePassWithRectPath()

auto impeller::testing::CreatePassWithRectPath	(	Rect	rect,
		std::optional< Rect >	bounds_hint,
		ContentBoundsPromise	bounds_promise = `ContentBoundsPromise::kUnknown`,
		bool	collapse = `false`
	)

Definition at line 110 of file entity_unittests.cc.

                           {
  auto subpass = std::make_unique<EntityPass>();
  Entity entity;
  entity.SetContents(SolidColorContents::Make(
      PathBuilder{}.AddRect(rect).TakePath(), Color::Red()));
  subpass->AddEntity(std::move(entity));
  subpass->SetDelegate(std::make_unique<TestPassDelegate>(collapse));
  subpass->SetBoundsLimit(bounds_hint, bounds_promise);
  return subpass;
}

◆ CreateStringFromMapping()

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

Definition at line 23 of file shader_archive_unittests.cc.

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

◆ CreateSurface()

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

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

◆ CreateTestYUVTextures()

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

static

Definition at line 1855 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->GetResourceAllocator()) ||
      !context->GetCommandQueue()->Submit({cmd_buffer}).ok()) {
    FML_DLOG(ERROR) << "Could not copy contents into Y/UV texture.";
  }
 
  return {y_texture, uv_texture};
}

◆ doNothing()

void impeller::testing::doNothing ( )

Definition at line 42 of file mock_gles.cc.

42{}

◆ flip_lr()

template<typename R >

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

inlinestaticconstexpr

Definition at line 1279 of file rect_unittests.cc.

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

◆ flip_lrtb()

template<typename R >

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

inlinestaticconstexpr

Definition at line 1291 of file rect_unittests.cc.

                                            {
  return flip_lr(flip_tb(rect));
}

◆ flip_tb()

template<typename R >

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

inlinestaticconstexpr

Definition at line 1285 of file rect_unittests.cc.

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

◆ GetBlendModeSelection()

static BlendModeSelection impeller::testing::GetBlendModeSelection ( )

static

Definition at line 188 of file aiks_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};
}

◆ GetCoverageOfFirstEntity()

template<typename Contents >

static std::optional< Rect > impeller::testing::GetCoverageOfFirstEntity ( const Picture & picture )

static

Definition at line 1547 of file dl_unittests.cc.

                                                                          {
  std::optional<Rect> coverage;
  picture.pass->IterateAllEntities([&coverage](Entity& entity) {
    if (std::static_pointer_cast<Contents>(entity.GetContents())) {
      auto contents = std::static_pointer_cast<Contents>(entity.GetContents());
      Entity entity;
      coverage = contents->GetCoverage(entity);
      return false;
    }
    return true;
  });
  return coverage;
}

◆ GetMockVulkanFunctions()

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

Definition at line 926 of file mock_vulkan.cc.

                     {
  MockDevice* mock_device = reinterpret_cast<MockDevice*>(device);
  return mock_device->GetCalledFunctions();
}

◆ INSTANTIATE_COMPUTE_SUITE()

impeller::testing::INSTANTIATE_COMPUTE_SUITE ( ComputeTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [1/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( AiksTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [2/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( BlendFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [3/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( BlitPassTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [4/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( DisplayListTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [5/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( GaussianBlurFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [6/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( HostBufferTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [7/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( MatrixFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [8/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RendererDartTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [9/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RuntimeStageTest )

◆ 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 34 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);
}

◆ MaskBlurVariantTest()

static Picture impeller::testing::MaskBlurVariantTest	(	const AiksTest &	test_context,
		const MaskBlurTestConfig &	config
	)

static

Definition at line 304 of file aiks_blur_unittests.cc.

                                                                     {
  Canvas canvas;
  canvas.Scale(test_context.GetContentScale());
  canvas.Scale(Vector2{0.8f, 0.8f});
  Paint paint;
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kNormal,
      .sigma = Sigma{1},
  };
 
  canvas.DrawPaint({.color = Color::AntiqueWhite()});
 
  paint.mask_blur_descriptor->style = config.style;
  paint.mask_blur_descriptor->sigma = Sigma{config.sigma};
  paint.image_filter = config.image_filter;
  paint.invert_colors = config.invert_colors;
  paint.blend_mode = config.blend_mode;
 
  const Scalar x = 50;
  const Scalar radius = 20.0f;
  const Scalar y_spacing = 100.0f;
 
  Scalar y = 50;
  paint.color = Color::Crimson().WithAlpha(config.alpha);
  canvas.DrawRect(Rect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                 radius, 60.0f - radius),
                  paint);
 
  y += y_spacing;
  paint.color = Color::Blue().WithAlpha(config.alpha);
  canvas.DrawCircle({x + 25, y + 25}, radius, paint);
 
  y += y_spacing;
  paint.color = Color::Green().WithAlpha(config.alpha);
  canvas.DrawOval(Rect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                 radius, 60.0f - radius),
                  paint);
 
  y += y_spacing;
  paint.color = Color::Purple().WithAlpha(config.alpha);
  canvas.DrawRRect(Rect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                   {radius, radius},                    //
                   paint);
 
  y += y_spacing;
  paint.color = Color::Orange().WithAlpha(config.alpha);
  canvas.DrawRRect(Rect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                   {radius, 5.0f}, paint);
 
  y += y_spacing;
  paint.color = Color::Maroon().WithAlpha(config.alpha);
  canvas.DrawPath(PathBuilder{}
                      .MoveTo({x + 0, y + 60})
                      .LineTo({x + 30, y + 0})
                      .LineTo({x + 60, y + 60})
                      .Close()
                      .TakePath(),
                  paint);
 
  y += y_spacing;
  paint.color = Color::Maroon().WithAlpha(config.alpha);
  canvas.DrawPath(PathBuilder{}
                      .AddArc(Rect::MakeXYWH(x + 5, y, 50, 50),
                              Radians{kPi / 2}, Radians{kPi})
                      .AddArc(Rect::MakeXYWH(x + 25, y, 50, 50),
                              Radians{kPi / 2}, Radians{kPi})
                      .Close()
                      .TakePath(),
                  paint);
 
  return canvas.EndRecordingAsPicture();
}

◆ mockBeginQueryEXT()

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

Definition at line 129 of file mock_gles.cc.

                                                 {
  RecordGLCall("glBeginQueryEXT");
}

◆ mockDeleteQueriesEXT()

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

Definition at line 159 of file mock_gles.cc.

                                                               {
  RecordGLCall("glDeleteQueriesEXT");
}

◆ mockEndQueryEXT()

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

Definition at line 136 of file mock_gles.cc.

                                {
  RecordGLCall("glEndQueryEXT");
}

◆ mockGenQueriesEXT()

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

Definition at line 119 of file mock_gles.cc.

                                               {
  RecordGLCall("glGenQueriesEXT");
  for (auto i = 0; i < n; i++) {
    ids[i] = i + 1;
  }
}

◆ mockGetError()

GLenum impeller::testing::mockGetError ( )

Definition at line 95 of file mock_gles.cc.

                      {
  return GL_NO_ERROR;
}

◆ mockGetIntegerv()

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

Definition at line 78 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;
    default:
      *value = 0;
      break;
  }
}

◆ mockGetQueryObjectui64vEXT()

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

Definition at line 151 of file mock_gles.cc.

                                                                            {
  RecordGLCall("glGetQueryObjectui64vEXT");
  *result = 1000u;
}

◆ mockGetQueryObjectuivEXT()

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

Definition at line 143 of file mock_gles.cc.

                                                                        {
  RecordGLCall("glGetQueryObjectuivEXT");
  *result = GL_TRUE;
}

◆ mockGetString()

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

Definition at line 50 of file mock_gles.cc.

                                                {
  switch (name) {
    case GL_VENDOR:
      return kMockVendor;
    case GL_VERSION:
      return g_version;
    case GL_SHADING_LANGUAGE_VERSION:
      return kMockShadingLanguageVersion;
    default:
      return (unsigned char*)"";
  }
}

◆ mockGetStringi()

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

Definition at line 66 of file mock_gles.cc.

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

◆ mockPopDebugGroupKHR()

void impeller::testing::mockPopDebugGroupKHR ( )

Definition at line 102 of file mock_gles.cc.

                            {
  RecordGLCall("PopDebugGroupKHR");
}

◆ mockPushDebugGroupKHR()

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

Definition at line 109 of file mock_gles.cc.

                                                  {
  RecordGLCall("PushDebugGroupKHR");
}

◆ RecordGLCall()

void impeller::testing::RecordGLCall ( const char * name )

Definition at line 29 of file mock_gles.cc.

                                    {
  if (auto mock_gles = g_mock_gles.lock()) {
    mock_gles->RecordCall(name);
  }
}

◆ RenderTextInCanvasSkia()

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

Definition at line 550 of file aiks_unittests.cc.

                                                        {}) {
  // Draw the baseline.
  canvas.DrawRect(
      Rect::MakeXYWH(options.position.x - 50, options.position.y, 900, 10),
      Paint{.color = Color::Aqua().WithAlpha(0.25)});
 
  // Mark the point at which the text is drawn.
  canvas.DrawCircle(options.position, 5.0,
                    Paint{.color = Color::Red().WithAlpha(0.25)});
 
  // Construct the text blob.
  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();
  SkFont sk_font(font_mgr->makeFromData(mapping), options.font_size);
  auto blob = SkTextBlob::MakeFromString(text.c_str(), sk_font);
  if (!blob) {
    return false;
  }
 
  // Create the Impeller text frame and draw it at the designated baseline.
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
 
  Paint text_paint;
  text_paint.color = options.color;
  text_paint.mask_blur_descriptor = options.mask_blur_descriptor;
  text_paint.stroke_width = 1;
  text_paint.style =
      options.stroke ? Paint::Style::kStroke : Paint::Style::kFill;
  canvas.DrawTextFrame(frame, options.position, text_paint);
  return true;
}

◆ RenderTextInCanvasSTB()

bool impeller::testing::RenderTextInCanvasSTB	(	const std::shared_ptr< Context > &	context,
		Canvas &	canvas,
		const std::string &	text,
		const std::string &	font_fixture,
		TextRenderOptions	options = `{}`
	)

Definition at line 590 of file aiks_unittests.cc.

                                                       {}) {
  // Draw the baseline.
  canvas.DrawRect(
      Rect::MakeXYWH(options.position.x - 50, options.position.y, 900, 10),
      Paint{.color = Color::Aqua().WithAlpha(0.25)});
 
  // Mark the point at which the text is drawn.
  canvas.DrawCircle(options.position, 5.0,
                    Paint{.color = Color::Red().WithAlpha(0.25)});
 
  // Construct the text blob.
  auto mapping = flutter::testing::OpenFixtureAsMapping(font_fixture.c_str());
  if (!mapping) {
    return false;
  }
  auto typeface_stb = std::make_shared<TypefaceSTB>(std::move(mapping));
 
  auto frame = MakeTextFrameSTB(
      typeface_stb, Font::Metrics{.point_size = options.font_size}, text);
 
  Paint text_paint;
  text_paint.color = options.color;
  canvas.DrawTextFrame(frame, options.position, text_paint);
  return true;
}

◆ RGBToYUV()

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

static

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

◆ SetSwapchainImageSize()

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

Override the image size returned by all swapchain images.

Definition at line 932 of file mock_vulkan.cc.

                                       {
  currentImageSize = size;
}

◆ swap_nan() [1/2]

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

inlinestaticconstexpr

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

◆ swap_nan() [2/2]

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

inlinestaticconstexpr

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

◆ TEST() [1/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		DisableLocalBoundsRectForFilteredSaveLayers
	)

Definition at line 340 of file canvas_unittests.cc.

                                                                  {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
 
  Canvas canvas(initial_cull);
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
 
  canvas.Save();
  canvas.SaveLayer(
      Paint{.image_filter = ImageFilter::MakeBlur(
                Sigma(10), Sigma(10), FilterContents::BlurStyle::kNormal,
                Entity::TileMode::kDecal)});
  ASSERT_FALSE(canvas.GetCurrentLocalCullingBounds().has_value());
 
  canvas.Restore();
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
}

◆ TEST() [2/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		EmptyCullRect
	)

Definition at line 18 of file canvas_unittests.cc.

                                    {
  Canvas canvas;
 
  ASSERT_FALSE(canvas.GetCurrentLocalCullingBounds().has_value());
}

◆ TEST() [3/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		InitialCullRect
	)

Definition at line 24 of file canvas_unittests.cc.

                                      {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
 
  Canvas canvas(initial_cull);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), initial_cull);
}

◆ TEST() [4/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		PathClipDiffAgainstEmptyCullRect
	)

Definition at line 277 of file canvas_unittests.cc.

                                                       {
  PathBuilder builder;
  builder.AddRect(Rect::MakeXYWH(5, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(5, 14, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 14, 1, 1));
  Path path = builder.TakePath();
 
  Canvas canvas;
  canvas.ClipPath(path, Entity::ClipOperation::kDifference);
 
  ASSERT_FALSE(canvas.GetCurrentLocalCullingBounds().has_value());
}

◆ TEST() [5/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		PathClipDiffAgainstFullyCoveredCullRect
	)

Definition at line 325 of file canvas_unittests.cc.

                                                              {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  PathBuilder builder;
  builder.AddRect(Rect::MakeXYWH(0, 0, 100, 100));
  Path path = builder.TakePath();
  // Diff clip of Paths is ignored due to complexity
  Rect result_cull = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipPath(path, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [6/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		PathClipDiffAgainstNonCoveredCullRect
	)

Definition at line 308 of file canvas_unittests.cc.

                                                            {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  PathBuilder builder;
  builder.AddRect(Rect::MakeXYWH(5, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(5, 14, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 14, 1, 1));
  Path path = builder.TakePath();
  Rect result_cull = Rect::MakeXYWH(0, 0, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipPath(path, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [7/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		PathClipIntersectAgainstCullRect
	)

Definition at line 291 of file canvas_unittests.cc.

                                                       {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  PathBuilder builder;
  builder.AddRect(Rect::MakeXYWH(5, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(5, 14, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 14, 1, 1));
  Path path = builder.TakePath();
  Rect result_cull = Rect::MakeXYWH(5, 5, 5, 5);
 
  Canvas canvas(initial_cull);
  canvas.ClipPath(path, Entity::ClipOperation::kIntersect);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [8/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		PathClipIntersectAgainstEmptyCullRect
	)

Definition at line 261 of file canvas_unittests.cc.

                                                            {
  PathBuilder builder;
  builder.AddRect(Rect::MakeXYWH(5, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(5, 14, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 5, 1, 1));
  builder.AddRect(Rect::MakeXYWH(14, 14, 1, 1));
  Path path = builder.TakePath();
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas;
  canvas.ClipPath(path, Entity::ClipOperation::kIntersect);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), rect_clip);
}

◆ TEST() [9/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffAboveCullRect
	)

Definition at line 98 of file canvas_unittests.cc.

                                                {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(0, 0, 20, 4);
  Rect result_cull = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [10/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffAgainstEmptyCullRect
	)

Definition at line 65 of file canvas_unittests.cc.

                                                       {
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas;
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_FALSE(canvas.GetCurrentLocalCullingBounds().has_value());
}

◆ TEST() [11/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffAgainstHCoveredCullRect
	)

Definition at line 158 of file canvas_unittests.cc.

                                                          {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(0, 5, 10, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 10, 5);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [12/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffAgainstNonCoveredCullRect
	)

Definition at line 86 of file canvas_unittests.cc.

                                                            {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [13/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffAgainstVCoveredCullRect
	)

Definition at line 146 of file canvas_unittests.cc.

                                                          {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, 0, 10, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 5, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [14/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffBelowCullRect
	)

Definition at line 110 of file canvas_unittests.cc.

                                                {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(0, 16, 20, 4);
  Rect result_cull = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [15/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffLeftOfCullRect
	)

Definition at line 122 of file canvas_unittests.cc.

                                                 {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(0, 0, 4, 20);
  Rect result_cull = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [16/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipDiffRightOfCullRect
	)

Definition at line 134 of file canvas_unittests.cc.

                                                  {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(16, 0, 4, 20);
  Rect result_cull = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [17/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipIntersectAgainstCullRect
	)

Definition at line 74 of file canvas_unittests.cc.

                                                       {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
  Rect result_cull = Rect::MakeXYWH(5, 5, 5, 5);
 
  Canvas canvas(initial_cull);
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kIntersect);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [18/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RectClipIntersectAgainstEmptyCullRect
	)

Definition at line 55 of file canvas_unittests.cc.

                                                            {
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas;
  canvas.ClipRect(rect_clip, Entity::ClipOperation::kIntersect);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), rect_clip);
}

◆ TEST() [19/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipDiffAgainstEmptyCullRect
	)

Definition at line 180 of file canvas_unittests.cc.

                                                        {
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas;
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kDifference);
 
  ASSERT_FALSE(canvas.GetCurrentLocalCullingBounds().has_value());
}

◆ TEST() [20/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipDiffAgainstHFullyCoveredCullRect
	)

Definition at line 249 of file canvas_unittests.cc.

                                                                {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(-2, 5, 14, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 10, 5);
 
  Canvas canvas(initial_cull);
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [21/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipDiffAgainstHPartiallyCoveredCullRect
	)

Definition at line 237 of file canvas_unittests.cc.

                                                                    {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(0, 5, 10, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 10, 6);
 
  Canvas canvas(initial_cull);
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [22/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipDiffAgainstNonCoveredCullRect
	)

Definition at line 201 of file canvas_unittests.cc.

                                                             {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [23/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipDiffAgainstVFullyCoveredCullRect
	)

Definition at line 225 of file canvas_unittests.cc.

                                                                {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, -2, 10, 14);
  Rect result_cull = Rect::MakeXYWH(0, 0, 5, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [24/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipDiffAgainstVPartiallyCoveredCullRect
	)

Definition at line 213 of file canvas_unittests.cc.

                                                                    {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, 0, 10, 10);
  Rect result_cull = Rect::MakeXYWH(0, 0, 6, 10);
 
  Canvas canvas(initial_cull);
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kDifference);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [25/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipIntersectAgainstCullRect
	)

Definition at line 189 of file canvas_unittests.cc.

                                                        {
  Rect initial_cull = Rect::MakeXYWH(0, 0, 10, 10);
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
  Rect result_cull = Rect::MakeXYWH(5, 5, 5, 5);
 
  Canvas canvas(initial_cull);
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kIntersect);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), result_cull);
}

◆ TEST() [26/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		RRectClipIntersectAgainstEmptyCullRect
	)

Definition at line 170 of file canvas_unittests.cc.

                                                             {
  Rect rect_clip = Rect::MakeXYWH(5, 5, 10, 10);
 
  Canvas canvas;
  canvas.ClipRRect(rect_clip, {1, 1}, Entity::ClipOperation::kIntersect);
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), rect_clip);
}

◆ TEST() [27/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		ScaledCullRect
	)

Definition at line 44 of file canvas_unittests.cc.

                                     {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  Rect scaled_cull = Rect::MakeXYWH(10, 10, 20, 20);
 
  Canvas canvas(initial_cull);
  canvas.Scale(Vector2(0.5, 0.5));
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), scaled_cull);
}

◆ TEST() [28/377]

impeller::testing::TEST	(	AiksCanvasTest	,
		TranslatedCullRect
	)

Definition at line 33 of file canvas_unittests.cc.

                                         {
  Rect initial_cull = Rect::MakeXYWH(5, 5, 10, 10);
  Rect translated_cull = Rect::MakeXYWH(0, 0, 10, 10);
 
  Canvas canvas(initial_cull);
  canvas.Translate(Vector3(5, 5, 0));
 
  ASSERT_TRUE(canvas.GetCurrentLocalCullingBounds().has_value());
  ASSERT_EQ(canvas.GetCurrentLocalCullingBounds().value(), translated_cull);
}

◆ TEST() [29/377]

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

◆ TEST() [30/377]

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

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

◆ TEST() [31/377]

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

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

◆ TEST() [32/377]

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

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

◆ TEST() [33/377]

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

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

◆ TEST() [34/377]

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

Definition at line 257 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() [35/377]

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

Definition at line 250 of file base_unittests.cc.

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

◆ TEST() [36/377]

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

◆ TEST() [37/377]

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

Definition at line 35 of file capabilities_unittests.cc.

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

◆ TEST() [38/377]

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

Definition at line 45 of file capabilities_unittests.cc.

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

◆ TEST() [39/377]

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

Definition at line 55 of file capabilities_unittests.cc.

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

◆ TEST() [40/377]

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

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

◆ TEST() [41/377]

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

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

◆ TEST() [42/377]

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

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

◆ TEST() [43/377]

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

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

◆ TEST() [44/377]

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

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

◆ TEST() [45/377]

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

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

◆ TEST() [46/377]

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

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

◆ TEST() [47/377]

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

Definition at line 16 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::shared_ptr<CommandEncoderVK> encoder;
    std::thread thread([&] {
      CommandEncoderFactoryVK factory(context);
      encoder = factory.Create();
    });
    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);
}

◆ TEST() [48/377]

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

Definition at line 115 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();
  }
 
  // Wait for the pool to be reclaimed.
  for (auto i = 0u; i < 2u; i++) {
    auto waiter = fml::AutoResetWaitableEvent();
    auto rattle = DeathRattle([&waiter]() { waiter.Signal(); });
    {
      UniqueResourceVKT<DeathRattle> resource(context->GetResourceManager(),
                                              std::move(rattle));
    }
    waiter.Wait();
  }
 
  {
    // 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 = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkCreateCommandPool"),
            1u);
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkAllocateCommandBuffers"),
      1u);
 
  context->Shutdown();
}

◆ TEST() [49/377]

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

Definition at line 14 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();
}

◆ TEST() [50/377]

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

Definition at line 43 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();
}

◆ TEST() [51/377]

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

Definition at line 76 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();
  }
 
  // Add something to the resource manager and have it notify us when it's
  // destroyed. That should give us a non-flaky signal that the pool has been
  // reclaimed as well.
  auto waiter = fml::AutoResetWaitableEvent();
  auto rattle = DeathRattle([&waiter]() { waiter.Signal(); });
  {
    UniqueResourceVKT<DeathRattle> resource(context->GetResourceManager(),
                                            std::move(rattle));
  }
  waiter.Wait();
 
  // 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 = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkCreateCommandPool"),
            1u);
 
  context->Shutdown();
}

◆ TEST() [52/377]

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

Definition at line 205 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.
  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);
}

◆ TEST() [53/377]

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

Definition at line 160 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.
  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);
}

◆ TEST() [54/377]

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

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

◆ TEST() [55/377]

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

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

◆ TEST() [56/377]

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

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

◆ TEST() [57/377]

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

Definition at line 132 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());
}

◆ TEST() [58/377]

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

Definition at line 146 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());
}

◆ TEST() [59/377]

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

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

◆ TEST() [60/377]

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

Definition at line 75 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());
}

◆ TEST() [61/377]

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

Definition at line 116 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());
}

◆ TEST() [62/377]

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

Definition at line 29 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());
}

◆ TEST() [63/377]

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

Definition at line 44 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());
}

◆ TEST() [64/377]

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

Definition at line 94 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());
}

◆ TEST() [65/377]

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

Definition at line 225 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(),
               "");
}

◆ TEST() [66/377]

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

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

◆ TEST() [67/377]

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

Definition at line 214 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());
}

◆ TEST() [68/377]

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

Definition at line 15 of file descriptor_pool_vk_unittests.cc.

                                                                             {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto const pool1 = context->GetDescriptorPoolRecycler()->Get();
  auto const pool2 = context->GetDescriptorPoolRecycler()->Get();
 
  // The two descriptor pools should be different.
  EXPECT_NE(pool1.get(), pool2.get());
 
  context->Shutdown();
}

◆ TEST() [69/377]

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

Definition at line 65 of file descriptor_pool_vk_unittests.cc.

                                                                               {
  auto const context = MockVulkanContextBuilder().Build();
 
  // Create 33 pools
  {
    std::vector<std::unique_ptr<DescriptorPoolVK>> pools;
    for (auto i = 0u; i < 33; i++) {
      auto pool = std::make_unique<DescriptorPoolVK>(context);
      pool->AllocateDescriptorSets({}, *context);
      pools.push_back(std::move(pool));
    }
  }
 
  // See note above.
  for (auto i = 0u; i < 2; i++) {
    auto waiter = fml::AutoResetWaitableEvent();
    auto rattle = fml::ScopedCleanupClosure([&waiter]() { waiter.Signal(); });
    {
      UniqueResourceVKT<fml::ScopedCleanupClosure> resource(
          context->GetResourceManager(), std::move(rattle));
    }
    waiter.Wait();
  }
 
  auto const called = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkCreateDescriptorPool"),
      33u);
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkResetDescriptorPool"),
            33u);
 
  // Now create 33 more descriptor pools and observe that only one more is
  // allocated.
  {
    std::vector<std::unique_ptr<DescriptorPoolVK>> pools;
    for (auto i = 0u; i < 33; i++) {
      auto pool = std::make_unique<DescriptorPoolVK>(context);
      pool->AllocateDescriptorSets({}, *context);
      pools.push_back(std::move(pool));
    }
  }
 
  for (auto i = 0u; i < 2; i++) {
    auto waiter = fml::AutoResetWaitableEvent();
    auto rattle = fml::ScopedCleanupClosure([&waiter]() { waiter.Signal(); });
    {
      UniqueResourceVKT<fml::ScopedCleanupClosure> resource(
          context->GetResourceManager(), std::move(rattle));
    }
    waiter.Wait();
  }
 
  auto const 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();
}

◆ TEST() [70/377]

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

Definition at line 27 of file descriptor_pool_vk_unittests.cc.

                                                                        {
  auto const context = MockVulkanContextBuilder().Build();
 
  {
    // Fetch a pool (which will be created).
    auto pool = DescriptorPoolVK(context);
    pool.AllocateDescriptorSets({}, *context);
  }
 
  // There is a chance that the first death rattle item below is destroyed in
  // the same reclaim cycle as the pool allocation above. These items are placed
  // into a std::vector and free'd, which may free in reverse order. That would
  // imply that the death rattle and subsequent waitable event fires before the
  // pool is reset. To work around this, we can either manually remove items
  // from the vector or use two death rattles.
  for (auto i = 0u; i < 2; i++) {
    // Add something to the resource manager and have it notify us when it's
    // destroyed. That should give us a non-flaky signal that the pool has been
    // reclaimed as well.
    auto waiter = fml::AutoResetWaitableEvent();
    auto rattle = fml::ScopedCleanupClosure([&waiter]() { waiter.Signal(); });
    {
      UniqueResourceVKT<fml::ScopedCleanupClosure> resource(
          context->GetResourceManager(), std::move(rattle));
    }
    waiter.Wait();
  }
 
  auto const pool = context->GetDescriptorPoolRecycler()->Get();
 
  // Now check that we only ever created one pool.
  auto const called = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkCreateDescriptorPool"), 1u);
 
  context->Shutdown();
}

◆ TEST() [71/377]

impeller::testing::TEST	(	DisplayListTest	,
		CircleBoundsComputation
	)

Definition at line 1584 of file dl_unittests.cc.

                                               {
  SkPath path = SkPath().addCircle(0, 0, 5);
 
  flutter::DlPaint paint;
  flutter::DisplayListBuilder builder;
 
  builder.DrawPath(path, paint);
  auto display_list = builder.Build();
 
  DlDispatcher dispatcher;
  display_list->Dispatch(dispatcher);
  auto picture = dispatcher.EndRecordingAsPicture();
 
  std::optional<Rect> coverage =
      GetCoverageOfFirstEntity<SolidColorContents>(picture);
 
  ASSERT_TRUE(coverage.has_value());
  ASSERT_EQ(coverage.value_or(Rect::MakeMaximum()),
            Rect::MakeLTRB(-5, -5, 5, 5));
}

◆ TEST() [72/377]

impeller::testing::TEST	(	DisplayListTest	,
		RRectBoundsComputation
	)

Definition at line 1561 of file dl_unittests.cc.

                                              {
  SkRRect rrect = SkRRect::MakeRectXY(SkRect::MakeLTRB(0, 0, 100, 100), 4, 4);
  SkPath path = SkPath().addRRect(rrect);
 
  flutter::DlPaint paint;
  flutter::DisplayListBuilder builder;
 
  builder.DrawPath(path, paint);
  auto display_list = builder.Build();
 
  DlDispatcher dispatcher;
  display_list->Dispatch(dispatcher);
  auto picture = dispatcher.EndRecordingAsPicture();
 
  std::optional<Rect> coverage =
      GetCoverageOfFirstEntity<SolidColorContents>(picture);
 
  // Validate that the RRect coverage is _exactly_ the same as the input rect.
  ASSERT_TRUE(coverage.has_value());
  ASSERT_EQ(coverage.value_or(Rect::MakeMaximum()),
            Rect::MakeLTRB(0, 0, 100, 100));
}

◆ TEST() [73/377]

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

Definition at line 139 of file geometry_unittests.cc.

                                                   {
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(Vector2{3.0, 3.0}));
  EXPECT_EQ(Geometry::MakeStrokePath({}, 0.5)->ComputeAlphaCoverage(entity), 1);
  EXPECT_EQ(Geometry::MakeStrokePath({}, 0.1)->ComputeAlphaCoverage(entity), 1);
  EXPECT_EQ(Geometry::MakeStrokePath({}, 0.05)->ComputeAlphaCoverage(entity),
            1);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, 0.01)->ComputeAlphaCoverage(entity),
              0.6, 0.1);
  EXPECT_NEAR(
      Geometry::MakeStrokePath({}, 0.0000005)->ComputeAlphaCoverage(entity),
      1e-05, 0.001);
  EXPECT_EQ(Geometry::MakeStrokePath({}, 0)->ComputeAlphaCoverage(entity), 1);
  EXPECT_EQ(Geometry::MakeStrokePath({}, 40)->ComputeAlphaCoverage(entity), 1);
}

◆ TEST() [74/377]

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

Definition at line 78 of file geometry_unittests.cc.

                                                     {
  auto path = PathBuilder{}.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({}, Rect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, Rect()));
}

◆ TEST() [75/377]

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

Definition at line 88 of file geometry_unittests.cc.

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

◆ TEST() [76/377]

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

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

◆ TEST() [77/377]

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

Definition at line 97 of file geometry_unittests.cc.

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

◆ TEST() [78/377]

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

Definition at line 70 of file geometry_unittests.cc.

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

◆ TEST() [79/377]

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

Definition at line 123 of file geometry_unittests.cc.

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

◆ TEST() [80/377]

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

Definition at line 92 of file entity_pass_unittests.cc.

                                                            {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  Entity entity;
  EntityPassClipStack::ClipStateResult result = recorder.ApplyClipState(
      Contents::ClipCoverage{
          .type = Contents::ClipCoverage::Type::kAppend,
          .coverage = Rect::MakeLTRB(50, 50, 55, 55),
      },
      entity, 0, Point(0, 0));
  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, 55));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  // Restore the clip.
  auto restore_clip = std::make_shared<ClipRestoreContents>();
  restore_clip->SetRestoreHeight(0);
  entity.SetContents(std::move(restore_clip));
  recorder.ApplyClipState(
      Contents::ClipCoverage{
          .type = Contents::ClipCoverage::Type::kRestore,
          .coverage = Rect::MakeLTRB(50, 50, 55, 55),
      },
      entity, 0, Point(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);
}

◆ TEST() [81/377]

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

Definition at line 69 of file entity_pass_unittests.cc.

                                                      {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeSize(Size::MakeWH(100, 100)));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].clip_height, 0u);
 
  Entity entity;
  EntityPassClipStack::ClipStateResult result = recorder.ApplyClipState(
      Contents::ClipCoverage{
          .type = Contents::ClipCoverage::Type::kNoChange,
          .coverage = std::nullopt,
      },
      entity, 0, Point(0, 0));
  EXPECT_TRUE(result.should_render);
  EXPECT_FALSE(result.clip_did_change);
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeSize(Size::MakeWH(100, 100)));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].clip_height, 0u);
}

◆ TEST() [82/377]

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

Definition at line 57 of file entity_pass_unittests.cc.

                                                 {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
 
  Entity entity;
  recorder.RecordEntity(entity, Contents::ClipCoverage::Type::kNoChange,
                        Rect());
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
}

◆ TEST() [83/377]

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

Definition at line 46 of file entity_pass_unittests.cc.

                                                    {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
 
  Entity entity;
  recorder.RecordEntity(entity, Contents::ClipCoverage::Type::kRestore, Rect());
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
}

◆ TEST() [84/377]

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

Definition at line 16 of file entity_pass_unittests.cc.

                                                     {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
 
  Entity entity;
  recorder.RecordEntity(entity, Contents::ClipCoverage::Type::kAppend,
                        Rect::MakeLTRB(0, 0, 100, 100));
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  recorder.RecordEntity(entity, Contents::ClipCoverage::Type::kAppend,
                        Rect::MakeLTRB(0, 0, 50, 50));
  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, 50));
  // NOLINTEND(bugprone-unchecked-optional-access)
 
  recorder.RecordEntity(entity, Contents::ClipCoverage::Type::kRestore, Rect());
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  recorder.RecordEntity(entity, Contents::ClipCoverage::Type::kRestore, Rect());
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
}

◆ TEST() [85/377]

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

Definition at line 160 of file entity_pass_unittests.cc.

                                                           {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  Entity entity;
  {
    EntityPassClipStack::ClipStateResult result = recorder.ApplyClipState(
        Contents::ClipCoverage{
            .type = Contents::ClipCoverage::Type::kAppend,
            .coverage = Rect::MakeLTRB(50, 50, 55, 55),
        },
        entity, 0, Point(0, 0));
    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, 55));
  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.ApplyClipState(
        Contents::ClipCoverage{
            .type = Contents::ClipCoverage::Type::kAppend,
            .coverage = Rect::MakeLTRB(54, 54, 55, 55),
        },
        entity, 0, Point(0, 0));
    EXPECT_TRUE(result.should_render);
    EXPECT_TRUE(result.clip_did_change);
  }
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(54, 54, 55, 55));
 
  // End subpass.
  recorder.PopSubpass();
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55, 55));
}

◆ TEST() [86/377]

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

Definition at line 133 of file entity_pass_unittests.cc.

                                                 {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Restore the clip.
  Entity entity;
  auto restore_clip = std::make_shared<ClipRestoreContents>();
  restore_clip->SetRestoreHeight(0);
  entity.SetContents(std::move(restore_clip));
  EntityPassClipStack::ClipStateResult result = recorder.ApplyClipState(
      Contents::ClipCoverage{
          .type = Contents::ClipCoverage::Type::kRestore,
          .coverage = Rect::MakeLTRB(50, 50, 55, 55),
      },
      entity, 0, Point(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);
}

◆ TEST() [87/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		AddFenceDoesNothingIfTerminating
	)

Definition at line 86 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), [&signal]() { signal.Signal(); });
  }
 
  // Ensure the fence did _not_ signal.
  EXPECT_TRUE(signal.WaitWithTimeout(fml::TimeDelta::FromMilliseconds(100)));
}

◆ TEST() [88/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ExecutesFenceCallback
	)

Definition at line 28 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), [&signal]() { signal.Signal(); });
 
  signal.Wait();
}

◆ TEST() [89/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ExecutesFenceCallbackX2
	)

Definition at line 40 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), [&signal]() { signal.Signal(); });
 
  auto signal2 = fml::ManualResetWaitableEvent();
  auto fence2 = device.createFenceUnique({}).value;
  waiter->AddFence(std::move(fence2), [&signal2]() { signal2.Signal(); });
 
  signal.Wait();
  signal2.Wait();
}

◆ TEST() [90/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ExecutesNewFenceThenOldFence
	)

Definition at line 57 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), [&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), [&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();
}

◆ TEST() [91/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		IgnoresNullCallback
	)

Definition at line 19 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;
  EXPECT_FALSE(waiter->AddFence(std::move(fence), nullptr));
}

◆ TEST() [92/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		IgnoresNullFence
	)

Definition at line 13 of file fence_waiter_vk_unittests.cc.

                                          {
  auto const context = MockVulkanContextBuilder().Build();
  auto const waiter = context->GetFenceWaiter();
  EXPECT_FALSE(waiter->AddFence(vk::UniqueFence(), []() {}));
}

◆ TEST() [93/377]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		InProgressFencesStillWaitIfTerminated
	)

Definition at line 103 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), [&signal]() { signal.Signal(); });
 
  // Terminate the waiter.
  waiter->Terminate();
 
  // Signal the fence.
  raw_fence->SetStatus(vk::Result::eSuccess);
 
  // This will hang if the fence was not signalled.
  signal.Wait();
}

◆ TEST() [94/377]

impeller::testing::TEST	(	FilterInputTest	,
		CanSetLocalTransformForTexture
	)

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

◆ TEST() [95/377]

impeller::testing::TEST	(	FilterInputTest	,
		IsLeaf
	)

Definition at line 30 of file filter_input_unittests.cc.

                              {
  std::shared_ptr<FilterContents> leaf =
      ColorFilterContents::MakeBlend(BlendMode::kSource, {});
  ASSERT_TRUE(leaf->IsLeaf());
 
  auto base = ColorFilterContents::MakeMatrixFilter(FilterInput::Make(leaf),
                                                    Matrix(), {});
 
  ASSERT_TRUE(leaf->IsLeaf());
  ASSERT_FALSE(base->IsLeaf());
}

◆ TEST() [96/377]

impeller::testing::TEST	(	FilterInputTest	,
		SetCoverageInputs
	)

Definition at line 42 of file filter_input_unittests.cc.

                                         {
  std::shared_ptr<FilterContents> leaf =
      ColorFilterContents::MakeBlend(BlendMode::kSource, {});
  ASSERT_TRUE(leaf->IsLeaf());
 
  auto base = ColorFilterContents::MakeMatrixFilter(FilterInput::Make(leaf),
                                                    Matrix(), {});
 
  {
    auto result = base->GetCoverage({});
    ASSERT_FALSE(result.has_value());
  }
 
  auto coverage_rect = Rect::MakeLTRB(100, 100, 200, 200);
  base->SetLeafInputs(FilterInput::Make({coverage_rect}));
 
  {
    auto result = base->GetCoverage({});
    ASSERT_TRUE(result.has_value());
    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
    ASSERT_RECT_NEAR(result.value(), coverage_rect);
  }
}

◆ TEST() [97/377]

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

◆ TEST() [98/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CalculateSigmaForBlurRadius
	)

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

◆ TEST() [99/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CalculateSigmaValues
	)

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

◆ TEST() [100/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		Coefficients
	)

Definition at line 459 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};
  GaussianBlurPipeline::FragmentShader::KernelSamples samples =
      GenerateBlurInfo(parameters);
  EXPECT_EQ(samples.sample_count, 9);
 
  // 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[8 - i].coefficient);
    EXPECT_TRUE(samples.samples[i + 1].coefficient >
                samples.samples[i].coefficient);
  }
}

◆ TEST() [101/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CoverageEmpty
	)

Definition at line 112 of file gaussian_blur_filter_contents_unittests.cc.

                                                    {
  GaussianBlurFilterContents contents(
      /*sigma_x=*/0.0, /*sigma_y=*/0.0, Entity::TileMode::kDecal,
      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());
}

◆ TEST() [102/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CoverageSimple
	)

Definition at line 123 of file gaussian_blur_filter_contents_unittests.cc.

                                                     {
  GaussianBlurFilterContents contents(
      /*sigma_x=*/0.0, /*sigma_y=*/0.0, Entity::TileMode::kDecal,
      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));
}

◆ TEST() [103/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CoverageWithSigma
	)

Definition at line 136 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,
      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));
  }
}

◆ TEST() [104/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		Create
	)

Definition at line 104 of file gaussian_blur_filter_contents_unittests.cc.

                                             {
  GaussianBlurFilterContents contents(
      /*sigma_x=*/0.0, /*sigma_y=*/0.0, Entity::TileMode::kDecal,
      FilterContents::BlurStyle::kNormal, /*mask_geometry=*/nullptr);
  EXPECT_EQ(contents.GetSigmaX(), 0.0);
  EXPECT_EQ(contents.GetSigmaY(), 0.0);
}

◆ TEST() [105/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		FilterSourceCoverage
	)

Definition at line 199 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,
      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));
  }
}

◆ TEST() [106/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		LerpHackKernelSamplesComplex
	)

Definition at line 562 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};
  GaussianBlurPipeline::FragmentShader::KernelSamples kernel_samples =
      GenerateBlurInfo(parameters);
  EXPECT_EQ(kernel_samples.sample_count, 33);
  GaussianBlurPipeline::FragmentShader::KernelSamples 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) {
    auto sample = fast_kernel_samples.samples[i];
    fast_output += sample.coefficient * sampler(sample.uv_offset);
  }
 
  EXPECT_NEAR(output, fast_output, 0.1);
}

◆ TEST() [107/377]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		LerpHackKernelSamplesSimple
	)

Definition at line 484 of file gaussian_blur_filter_contents_unittests.cc.

                                                                  {
  GaussianBlurPipeline::FragmentShader::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,
              },
          },
  };
 
  GaussianBlurPipeline::FragmentShader::KernelSamples fast_kernel_samples =
      LerpHackKernelSamples(kernel_samples);
  EXPECT_EQ(fast_kernel_samples.sample_count, 3);
 
  GaussianBlurPipeline::FragmentShader::KernelSample* samples =
      kernel_samples.samples;
  GaussianBlurPipeline::FragmentShader::KernelSample* fast_samples =
      fast_kernel_samples.samples;
 
  //////////////////////////////////////////////////////////////////////////////
  // Check output kernel.
 
  EXPECT_FLOAT_EQ(fast_samples[0].uv_offset.x, -1.3333333);
  EXPECT_FLOAT_EQ(fast_samples[0].uv_offset.y, 0);
  EXPECT_FLOAT_EQ(fast_samples[0].coefficient, 0.3);
  EXPECT_FLOAT_EQ(fast_samples[1].uv_offset.x, 0);
  EXPECT_FLOAT_EQ(fast_samples[1].uv_offset.y, 0);
  EXPECT_FLOAT_EQ(fast_samples[1].coefficient, 0.4);
  EXPECT_FLOAT_EQ(fast_samples[2].uv_offset.x, 1.3333333);
  EXPECT_FLOAT_EQ(fast_samples[2].uv_offset.y, 0);
  EXPECT_FLOAT_EQ(fast_samples[2].coefficient, 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(fast_samples[0].uv_offset, data[0], data[1]) *
          fast_samples[0].coefficient +
      /*2nd*/ data[2] * fast_samples[1].coefficient +
      /*3rd*/ lerp(fast_samples[2].uv_offset, data[3], data[4]) *
          fast_samples[2].coefficient;
 
  EXPECT_NEAR(original_output, fast_output, 0.01);
}

◆ TEST() [108/377]

impeller::testing::TEST	(	GeometryTest	,
		BlendModeToString
	)

Definition at line 1678 of file geometry_unittests.cc.

                                      {
  using BlendT = std::underlying_type_t<BlendMode>;
  for (BlendT i = 0; i <= static_cast<BlendT>(BlendMode::kLast); i++) {
    auto mode = static_cast<BlendMode>(i);
    auto result = BlendModeToString(mode);
    switch (mode) { IMPELLER_FOR_EACH_BLEND_MODE(_BLEND_MODE_NAME_CHECK) }
  }
}

◆ TEST() [109/377]

impeller::testing::TEST	(	GeometryTest	,
		CanConvertBetweenDegressAndRadians
	)

Definition at line 1687 of file geometry_unittests.cc.

                                                       {
  {
    auto deg = Degrees{90.0};
    Radians rad = deg;
    ASSERT_FLOAT_EQ(rad.radians, kPiOver2);
  }
}

◆ TEST() [110/377]

impeller::testing::TEST	(	GeometryTest	,
		CanConvertTTypesExplicitly
	)

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

◆ TEST() [111/377]

impeller::testing::TEST	(	GeometryTest	,
		CanGenerateMipCounts
	)

Definition at line 595 of file geometry_unittests.cc.

                                         {
  ASSERT_EQ((Size{128, 128}.MipCount()), 7u);
  ASSERT_EQ((Size{128, 256}.MipCount()), 8u);
  ASSERT_EQ((Size{128, 130}.MipCount()), 8u);
  ASSERT_EQ((Size{128, 257}.MipCount()), 9u);
  ASSERT_EQ((Size{257, 128}.MipCount()), 9u);
  ASSERT_EQ((Size{128, 0}.MipCount()), 1u);
  ASSERT_EQ((Size{128, -25}.MipCount()), 1u);
  ASSERT_EQ((Size{-128, 25}.MipCount()), 1u);
  ASSERT_EQ((Size{1, 1}.MipCount()), 1u);
  ASSERT_EQ((Size{0, 0}.MipCount()), 1u);
}

◆ TEST() [112/377]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicPointOps
	)

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

◆ TEST() [113/377]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicPointOpsWithArithmeticTypes
	)

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

◆ TEST() [114/377]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicVector3Ops
	)

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

◆ TEST() [115/377]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicVector3OpsWithArithmeticTypes
	)

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

◆ TEST() [116/377]

impeller::testing::TEST	(	GeometryTest	,
		CanUsePointAssignmentOperators
	)

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

◆ TEST() [117/377]

impeller::testing::TEST	(	GeometryTest	,
		CanUseVector3AssignmentOperators
	)

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

◆ TEST() [118/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorApplyColorMatrix
	)

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

◆ TEST() [119/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorBlendReturnsExpectedResults
	)

Definition at line 1661 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)
  }
}

◆ TEST() [120/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorClamp01
	)

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

◆ TEST() [121/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorLerp
	)

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

◆ TEST() [122/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorLinearToSRGB
	)

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

◆ TEST() [123/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorMakeRGBA8
	)

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

◆ TEST() [124/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorPremultiply
	)

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

◆ TEST() [125/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorPrinting
	)

Definition at line 1770 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() [126/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorR8G8B8A8
	)

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

◆ TEST() [127/377]

impeller::testing::TEST	(	GeometryTest	,
		ColorSRGBToLinear
	)

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

◆ TEST() [128/377]

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() [129/377]

impeller::testing::TEST	(	GeometryTest	,
		Gradient
	)

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

◆ TEST() [130/377]

impeller::testing::TEST	(	GeometryTest	,
		HalfConversions
	)

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

◆ TEST() [131/377]

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

◆ TEST() [132/377]

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

◆ TEST() [133/377]

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

◆ TEST() [134/377]

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

◆ TEST() [135/377]

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

◆ TEST() [136/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetBasisVectors
	)

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

◆ TEST() [137/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetDirectionScale
	)

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

◆ TEST() [138/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetMaxBasisLength
	)

Definition at line 333 of file geometry_unittests.cc.

                                            {
  {
    auto m = Matrix::MakeScale({3, 1, 1});
    ASSERT_EQ(m.GetMaxBasisLength(), 3);
 
    m = m * Matrix::MakeSkew(0, 4);
    ASSERT_EQ(m.GetMaxBasisLength(), 5);
  }
 
  {
    auto m = Matrix::MakeScale({-3, 4, 2});
    ASSERT_EQ(m.GetMaxBasisLength(), 4);
  }
}

◆ TEST() [139/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetMaxBasisLengthXY
	)

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

◆ TEST() [140/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixLookAt
	)

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

◆ TEST() [141/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixMakeOrthographic
	)

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

◆ TEST() [142/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixMakePerspective
	)

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

◆ TEST() [143/377]

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

◆ TEST() [144/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixPrinting
	)

Definition at line 1695 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,
))");
  }
}

◆ TEST() [145/377]

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

◆ TEST() [146/377]

impeller::testing::TEST	(	GeometryTest	,
		MatrixTranslationScaleOnly
	)

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

◆ TEST() [147/377]

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

◆ TEST() [148/377]

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

◆ TEST() [149/377]

impeller::testing::TEST	(	GeometryTest	,
		PointAbs
	)

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

◆ TEST() [150/377]

impeller::testing::TEST	(	GeometryTest	,
		PointAngleTo
	)

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

◆ TEST() [151/377]

impeller::testing::TEST	(	GeometryTest	,
		PointCeil
	)

Definition at line 1082 of file geometry_unittests.cc.

                              {
  Point p(1.5, 2.3);
  Point result = p.Ceil();
  Point expected(2, 3);
  ASSERT_POINT_NEAR(result, expected);
}

◆ TEST() [152/377]

impeller::testing::TEST	(	GeometryTest	,
		PointCrossProduct
	)

Definition at line 908 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() [153/377]

impeller::testing::TEST	(	GeometryTest	,
		PointDotProduct
	)

Definition at line 888 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() [154/377]

impeller::testing::TEST	(	GeometryTest	,
		PointFloor
	)

Definition at line 1061 of file geometry_unittests.cc.

                               {
  Point p(1.5, 2.3);
  Point result = p.Floor();
  Point expected(1, 2);
  ASSERT_POINT_NEAR(result, expected);
}

◆ TEST() [155/377]

impeller::testing::TEST	(	GeometryTest	,
		PointIntegerCoercesToFloat
	)

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

◆ TEST() [156/377]

impeller::testing::TEST	(	GeometryTest	,
		PointLerp
	)

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

◆ TEST() [157/377]

impeller::testing::TEST	(	GeometryTest	,
		PointMax
	)

Definition at line 1040 of file geometry_unittests.cc.

                             {
  Point p(1, 2);
  Point result = p.Max({0, 10});
  Point expected(1, 10);
  ASSERT_POINT_NEAR(result, expected);
}

◆ TEST() [158/377]

impeller::testing::TEST	(	GeometryTest	,
		PointMin
	)

Definition at line 1019 of file geometry_unittests.cc.

                             {
  Point p(1, 2);
  Point result = p.Min({0, 10});
  Point expected(0, 2);
  ASSERT_POINT_NEAR(result, expected);
}

◆ TEST() [159/377]

impeller::testing::TEST	(	GeometryTest	,
		PointPrinting
	)

Definition at line 1722 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() [160/377]

impeller::testing::TEST	(	GeometryTest	,
		PointReflect
	)

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

◆ TEST() [161/377]

impeller::testing::TEST	(	GeometryTest	,
		PointRotate
	)

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

◆ TEST() [162/377]

impeller::testing::TEST	(	GeometryTest	,
		PointRound
	)

Definition at line 1103 of file geometry_unittests.cc.

                               {
  Point p(1.5, 2.3);
  Point result = p.Round();
  Point expected(2, 2);
  ASSERT_POINT_NEAR(result, expected);
}

◆ TEST() [163/377]

impeller::testing::TEST	(	GeometryTest	,
		QuaternionLerp
	)

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

◆ TEST() [164/377]

impeller::testing::TEST	(	GeometryTest	,
		QuaternionVectorMultiply
	)

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

◆ TEST() [165/377]

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

◆ TEST() [166/377]

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

◆ TEST() [167/377]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2AngleTo
	)

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

◆ TEST() [168/377]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2GetAlignment
	)

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

◆ TEST() [169/377]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2GetVector
	)

Definition at line 1151 of file geometry_unittests.cc.

                                              {
  SeparatedVector2 v(Vector2(10, 0));
  ASSERT_POINT_NEAR(v.GetVector(), Vector2(10, 0));
}

◆ TEST() [170/377]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2NormalizesWithConstructor
	)

Definition at line 1145 of file geometry_unittests.cc.

                                                              {
  SeparatedVector2 v(Vector2(10, 0));
  ASSERT_POINT_NEAR(v.direction, Vector2(1, 0));
  ASSERT_NEAR(v.magnitude, 10, kEhCloseEnough);
}

◆ TEST() [171/377]

impeller::testing::TEST	(	GeometryTest	,
		SizeCoercesToPoint
	)

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

◆ TEST() [172/377]

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

◆ TEST() [173/377]

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

◆ TEST() [174/377]

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

◆ TEST() [175/377]

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

◆ TEST() [176/377]

impeller::testing::TEST	(	GeometryTest	,
		ToIColor
	)

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

◆ TEST() [177/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Ceil
	)

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

◆ TEST() [178/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Floor
	)

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

◆ TEST() [179/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Lerp
	)

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

◆ TEST() [180/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Max
	)

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

◆ TEST() [181/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Min
	)

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

◆ TEST() [182/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Printing
	)

Definition at line 1738 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() [183/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Round
	)

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

◆ TEST() [184/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Ceil
	)

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

◆ TEST() [185/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Floor
	)

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

◆ TEST() [186/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Lerp
	)

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

◆ TEST() [187/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Max
	)

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

◆ TEST() [188/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Min
	)

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

◆ TEST() [189/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Printing
	)

Definition at line 1754 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() [190/377]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Round
	)

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

◆ TEST() [191/377]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		Coverage2x
	)

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

◆ TEST() [192/377]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		Coverage2xEffect
	)

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

◆ TEST() [193/377]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		CoverageEmpty
	)

Definition at line 50 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());
}

◆ TEST() [194/377]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		CoverageSimple
	)

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

◆ TEST() [195/377]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		Create
	)

Definition at line 45 of file matrix_filter_contents_unittests.cc.

                                       {
  MatrixFilterContents contents;
  EXPECT_TRUE(contents.IsTranslationOnly());
}

◆ TEST() [196/377]

impeller::testing::TEST	(	MatrixTest	,
		HasPerspective
	)

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

◆ TEST() [197/377]

impeller::testing::TEST	(	MatrixTest	,
		HasPerspective2D
	)

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

◆ TEST() [198/377]

impeller::testing::TEST	(	MatrixTest	,
		HasTranslation
	)

Definition at line 63 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());
}

◆ TEST() [199/377]

impeller::testing::TEST	(	MatrixTest	,
		IsAligned
	)

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

◆ TEST() [200/377]

impeller::testing::TEST	(	MatrixTest	,
		IsAligned2D
	)

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

◆ TEST() [201/377]

impeller::testing::TEST	(	MatrixTest	,
		Multiply
	)

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

◆ TEST() [202/377]

impeller::testing::TEST	(	MatrixTest	,
		TransformHomogenous
	)

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

◆ TEST() [203/377]

impeller::testing::TEST	(	MockGLES	,
		CanCallUnmockedFunction
	)

Definition at line 38 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.
}

◆ TEST() [204/377]

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

◆ TEST() [205/377]

impeller::testing::TEST	(	MockGLES	,
		CapturesPushAndPopDebugGroup
	)

Definition at line 25 of file mock_gles_unittests.cc.

                                             {
  auto mock_gles = MockGLES::Init();
 
  auto& gl = mock_gles->GetProcTable();
  gl.PushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 0, -1, "test");
  gl.PopDebugGroupKHR();
 
  auto calls = mock_gles->GetCapturedCalls();
  EXPECT_EQ(calls, std::vector<std::string>(
                       {"PushDebugGroupKHR", "PopDebugGroupKHR"}));
}

◆ TEST() [206/377]

impeller::testing::TEST	(	MockVulkanContextTest	,
		DefaultFenceAlwaysReportsSuccess
	)

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

◆ TEST() [207/377]

impeller::testing::TEST	(	MockVulkanContextTest	,
		IsThreadSafe
	)

Definition at line 13 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();
}

◆ TEST() [208/377]

impeller::testing::TEST	(	MockVulkanContextTest	,
		MockedFenceReportsStatus
	)

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

◆ TEST() [209/377]

impeller::testing::TEST	(	PathTest	,
		BoundingBoxCubic
	)

Definition at line 339 of file path_unittests.cc.

                                 {
  PathBuilder builder;
  auto path =
      builder.AddCubicCurve({120, 160}, {25, 200}, {220, 260}, {220, 40})
          .TakePath();
  auto box = path.GetBoundingBox();
  Rect expected = Rect::MakeXYWH(93.9101, 40, 126.09, 158.862);
  ASSERT_TRUE(box.has_value());
  ASSERT_RECT_NEAR(box.value_or(Rect::MakeMaximum()), expected);
}

◆ TEST() [210/377]

impeller::testing::TEST	(	PathTest	,
		BoundingBoxOfCompositePathIsCorrect
	)

Definition at line 350 of file path_unittests.cc.

                                                    {
  PathBuilder builder;
  builder.AddRoundedRect(Rect::MakeXYWH(10, 10, 300, 300), {50, 50, 50, 50});
  auto path = builder.TakePath();
  auto actual = path.GetBoundingBox();
  Rect expected = Rect::MakeXYWH(10, 10, 300, 300);
 
  ASSERT_TRUE(actual.has_value());
  ASSERT_RECT_NEAR(actual.value_or(Rect::MakeMaximum()), expected);
}

◆ TEST() [211/377]

impeller::testing::TEST	(	PathTest	,
		CanBeCloned
	)

Definition at line 501 of file path_unittests.cc.

                            {
  PathBuilder builder;
  builder.MoveTo({10, 10});
  builder.LineTo({20, 20});
  builder.SetBounds(Rect::MakeLTRB(0, 0, 100, 100));
  builder.SetConvexity(Convexity::kConvex);
 
  auto path_a = builder.TakePath(FillType::kOdd);
  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
  auto path_b = path_a;
 
  EXPECT_EQ(path_a.GetBoundingBox(), path_b.GetBoundingBox());
  EXPECT_EQ(path_a.GetFillType(), path_b.GetFillType());
  EXPECT_EQ(path_a.IsConvex(), path_b.IsConvex());
 
  auto poly_a = path_a.CreatePolyline(1.0);
  auto poly_b = path_b.CreatePolyline(1.0);
 
  ASSERT_EQ(poly_a.points->size(), poly_b.points->size());
  ASSERT_EQ(poly_a.contours.size(), poly_b.contours.size());
 
  for (auto i = 0u; i < poly_a.points->size(); i++) {
    EXPECT_EQ((*poly_a.points)[i], (*poly_b.points)[i]);
  }
 
  for (auto i = 0u; i < poly_a.contours.size(); i++) {
    EXPECT_EQ(poly_a.contours[i].start_index, poly_b.contours[i].start_index);
    EXPECT_EQ(poly_a.contours[i].start_direction,
              poly_b.contours[i].start_direction);
  }
}

◆ TEST() [212/377]

impeller::testing::TEST	(	PathTest	,
		CloseAfterMoveDoesNotAddNewLines
	)

Definition at line 471 of file path_unittests.cc.

                                                 {
  PathBuilder builder;
  auto path = builder.LineTo({0, 10})
                  .LineTo({10, 10})
                  .MoveTo({30, 30})  // Moves to (30, 30)
                  .Close()           // No Op
                  .Close()           // Still No op
                  .TakePath();
 
  EXPECT_EQ(path.GetComponentCount(), 4u);
  EXPECT_EQ(path.GetComponentCount(Path::ComponentType::kLinear), 2u);
  EXPECT_EQ(path.GetComponentCount(Path::ComponentType::kContour), 2u);
}

◆ TEST() [213/377]

impeller::testing::TEST	(	PathTest	,
		CloseAtOriginDoesNotAddNewLineSegment
	)

Definition at line 485 of file path_unittests.cc.

                                                      {
  PathBuilder builder;
  // Create a path that has a current position at the origin when close is
  // called. This should not insert a new line segment
  auto path = builder.LineTo({10, 0})
                  .LineTo({10, 10})
                  .LineTo({0, 10})
                  .LineTo({0, 0})
                  .Close()
                  .TakePath();
 
  EXPECT_EQ(path.GetComponentCount(), 6u);
  EXPECT_EQ(path.GetComponentCount(Path::ComponentType::kLinear), 4u);
  EXPECT_EQ(path.GetComponentCount(Path::ComponentType::kContour), 2u);
}

◆ TEST() [214/377]

impeller::testing::TEST	(	PathTest	,
		CubicPath
	)

Definition at line 324 of file path_unittests.cc.

                          {
  PathBuilder builder;
  auto path =
      builder.CubicCurveTo(Point(10, 10), Point(-10, -10), Point(20, 20))
          .TakePath();
 
  CubicPathComponent cubic;
  path.GetCubicComponentAtIndex(1, cubic);
 
  EXPECT_EQ(cubic.p1, Point(0, 0));
  EXPECT_EQ(cubic.cp1, Point(10, 10));
  EXPECT_EQ(cubic.cp2, Point(-10, -10));
  EXPECT_EQ(cubic.p2, Point(20, 20));
}

◆ TEST() [215/377]

impeller::testing::TEST	(	PathTest	,
		CubicPathComponentPolylineDoesNotIncludePointOne
	)

Definition at line 15 of file path_unittests.cc.

                                                                 {
  CubicPathComponent component({10, 10}, {20, 35}, {35, 20}, {40, 40});
  std::vector<Point> polyline;
  component.AppendPolylinePoints(1.0f, polyline);
  ASSERT_NE(polyline.front().x, 10);
  ASSERT_NE(polyline.front().y, 10);
  ASSERT_EQ(polyline.back().x, 40);
  ASSERT_EQ(polyline.back().y, 40);
}

◆ TEST() [216/377]

impeller::testing::TEST	(	PathTest	,
		EmptyPath
	)

Definition at line 384 of file path_unittests.cc.

                          {
  auto path = PathBuilder{}.TakePath();
  ASSERT_EQ(path.GetComponentCount(), 1u);
 
  ContourComponent c;
  path.GetContourComponentAtIndex(0, c);
  ASSERT_POINT_NEAR(c.destination, Point());
 
  Path::Polyline polyline = path.CreatePolyline(1.0f);
  ASSERT_TRUE(polyline.points->empty());
  ASSERT_TRUE(polyline.contours.empty());
}

◆ TEST() [217/377]

impeller::testing::TEST	(	PathTest	,
		ExtremaOfCubicPathComponentIsCorrect
	)

Definition at line 361 of file path_unittests.cc.

                                                     {
  CubicPathComponent cubic{{11.769268, 252.883148},
                           {-6.2857933, 204.356461},
                           {-4.53997231, 156.552902},
                           {17.0067291, 109.472488}};
  auto points = cubic.Extrema();
 
  ASSERT_EQ(points.size(), static_cast<size_t>(3));
  ASSERT_POINT_NEAR(points[2], cubic.Solve(0.455916));
}

◆ TEST() [218/377]

impeller::testing::TEST	(	PathTest	,
		PathAddRectPolylineHasCorrectContourData
	)

Definition at line 160 of file path_unittests.cc.

                                                         {
  Path::Polyline polyline = PathBuilder{}
                                .AddRect(Rect::MakeLTRB(50, 60, 70, 80))
                                .TakePath()
                                .CreatePolyline(1.0f);
  ASSERT_EQ(polyline.contours.size(), 1u);
  ASSERT_TRUE(polyline.contours[0].is_closed);
  ASSERT_EQ(polyline.contours[0].start_index, 0u);
  ASSERT_EQ(polyline.points->size(), 5u);
  ASSERT_EQ(polyline.GetPoint(0), Point(50, 60));
  ASSERT_EQ(polyline.GetPoint(1), Point(70, 60));
  ASSERT_EQ(polyline.GetPoint(2), Point(70, 80));
  ASSERT_EQ(polyline.GetPoint(3), Point(50, 80));
  ASSERT_EQ(polyline.GetPoint(4), Point(50, 60));
}

◆ TEST() [219/377]

impeller::testing::TEST	(	PathTest	,
		PathBuilderDoesNotMutateCopiedPaths
	)

Definition at line 533 of file path_unittests.cc.

                                                    {
  auto test_isolation =
      [](const std::function<void(PathBuilder & builder)>& mutator,
         bool will_close, Point mutation_offset, const std::string& label) {
        PathBuilder builder;
        builder.MoveTo({10, 10});
        builder.LineTo({20, 20});
        builder.LineTo({20, 10});
 
        auto verify_path = [](const Path& path, bool is_mutated, bool is_closed,
                              Point offset, const std::string& label) {
          if (is_mutated) {
            // We can only test the initial state before the mutator did
            // its work. We have >= 3 components and the first 3 components
            // will match what we saw before the mutation.
            EXPECT_GE(path.GetComponentCount(), 3u) << label;
          } else {
            EXPECT_EQ(path.GetComponentCount(), 3u) << label;
          }
          {
            ContourComponent contour;
            EXPECT_TRUE(path.GetContourComponentAtIndex(0, contour)) << label;
            EXPECT_EQ(contour.destination, offset + Point(10, 10)) << label;
            EXPECT_EQ(contour.is_closed, is_closed) << label;
          }
          {
            LinearPathComponent line;
            EXPECT_TRUE(path.GetLinearComponentAtIndex(1, line)) << label;
            EXPECT_EQ(line.p1, offset + Point(10, 10)) << label;
            EXPECT_EQ(line.p2, offset + Point(20, 20)) << label;
          }
          {
            LinearPathComponent line;
            EXPECT_TRUE(path.GetLinearComponentAtIndex(2, line)) << label;
            EXPECT_EQ(line.p1, offset + Point(20, 20)) << label;
            EXPECT_EQ(line.p2, offset + Point(20, 10)) << label;
          }
        };
 
        auto path1 = builder.CopyPath();
        verify_path(path1, false, false, {},
                    "Initial Path1 state before " + label);
 
        for (int i = 0; i < 10; i++) {
          auto path = builder.CopyPath();
          verify_path(
              path, false, false, {},
              "Extra CopyPath #" + std::to_string(i + 1) + " for " + label);
        }
        mutator(builder);
        verify_path(path1, false, false, {},
                    "Path1 state after subsequent " + label);
 
        auto path2 = builder.CopyPath();
        verify_path(path1, false, false, {},
                    "Path1 state after subsequent " + label + " and CopyPath");
        verify_path(path2, true, will_close, mutation_offset,
                    "Initial Path2 state with subsequent " + label);
      };
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.SetConvexity(Convexity::kConvex);
      },
      false, {}, "SetConvex");
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.SetConvexity(Convexity::kUnknown);
      },
      false, {}, "SetUnknownConvex");
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.Close();
      },
      true, {}, "Close");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.MoveTo({20, 30}, false);
      },
      false, {}, "Absolute MoveTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.MoveTo({20, 30}, true);
      },
      false, {}, "Relative MoveTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.LineTo({20, 30}, false);
      },
      false, {}, "Absolute LineTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.LineTo({20, 30}, true);
      },
      false, {}, "Relative LineTo");
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.HorizontalLineTo(100, false);
      },
      false, {}, "Absolute HorizontalLineTo");
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.HorizontalLineTo(100, true);
      },
      false, {}, "Relative HorizontalLineTo");
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.VerticalLineTo(100, false);
      },
      false, {}, "Absolute VerticalLineTo");
 
  test_isolation(
      [](PathBuilder& builder) {  //
        builder.VerticalLineTo(100, true);
      },
      false, {}, "Relative VerticalLineTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.QuadraticCurveTo({20, 30}, {30, 20}, false);
      },
      false, {}, "Absolute QuadraticCurveTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.QuadraticCurveTo({20, 30}, {30, 20}, true);
      },
      false, {}, "Relative QuadraticCurveTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.CubicCurveTo({20, 30}, {30, 20}, {30, 30}, false);
      },
      false, {}, "Absolute CubicCurveTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.CubicCurveTo({20, 30}, {30, 20}, {30, 30}, true);
      },
      false, {}, "Relative CubicCurveTo");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddLine({100, 100}, {150, 100});
      },
      false, {}, "AddLine");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddRect(Rect::MakeLTRB(100, 100, 120, 120));
      },
      false, {}, "AddRect");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddOval(Rect::MakeLTRB(100, 100, 120, 120));
      },
      false, {}, "AddOval");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddCircle({100, 100}, 20);
      },
      false, {}, "AddCircle");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddArc(Rect::MakeLTRB(100, 100, 120, 120), Degrees(10),
                       Degrees(170));
      },
      false, {}, "AddArc");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddQuadraticCurve({100, 100}, {150, 100}, {150, 150});
      },
      false, {}, "AddQuadraticCurve");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.AddCubicCurve({100, 100}, {150, 100}, {100, 150}, {150, 150});
      },
      false, {}, "AddCubicCurve");
 
  test_isolation(
      [](PathBuilder& builder) {
        builder.Shift({23, 42});
      },
      false, {23, 42}, "Shift");
}

◆ TEST() [220/377]

impeller::testing::TEST	(	PathTest	,
		PathBuilderSetsCorrectContourPropertiesForAddCommands
	)

Definition at line 44 of file path_unittests.cc.

                                                                      {
  // Closed shapes.
  {
    Path path = PathBuilder{}.AddCircle({100, 100}, 50).TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    EXPECT_POINT_NEAR(contour.destination, Point(100, 50));
    EXPECT_TRUE(contour.is_closed);
  }
 
  {
    Path path =
        PathBuilder{}.AddOval(Rect::MakeXYWH(100, 100, 100, 100)).TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    EXPECT_POINT_NEAR(contour.destination, Point(150, 100));
    EXPECT_TRUE(contour.is_closed);
  }
 
  {
    Path path =
        PathBuilder{}.AddRect(Rect::MakeXYWH(100, 100, 100, 100)).TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    EXPECT_POINT_NEAR(contour.destination, Point(100, 100));
    EXPECT_TRUE(contour.is_closed);
  }
 
  {
    Path path = PathBuilder{}
                    .AddRoundedRect(Rect::MakeXYWH(100, 100, 100, 100), 10)
                    .TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    EXPECT_POINT_NEAR(contour.destination, Point(110, 100));
    EXPECT_TRUE(contour.is_closed);
  }
 
  {
    Path path =
        PathBuilder{}
            .AddRoundedRect(Rect::MakeXYWH(100, 100, 100, 100), Size(10, 20))
            .TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    EXPECT_POINT_NEAR(contour.destination, Point(110, 100));
    EXPECT_TRUE(contour.is_closed);
  }
 
  // Open shapes.
  {
    Point p(100, 100);
    Path path = PathBuilder{}.AddLine(p, {200, 100}).TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    ASSERT_POINT_NEAR(contour.destination, p);
    ASSERT_FALSE(contour.is_closed);
  }
 
  {
    Path path =
        PathBuilder{}
            .AddCubicCurve({100, 100}, {100, 50}, {100, 150}, {200, 100})
            .TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    ASSERT_POINT_NEAR(contour.destination, Point(100, 100));
    ASSERT_FALSE(contour.is_closed);
  }
 
  {
    Path path = PathBuilder{}
                    .AddQuadraticCurve({100, 100}, {100, 50}, {200, 100})
                    .TakePath();
    ContourComponent contour;
    path.GetContourComponentAtIndex(0, contour);
    ASSERT_POINT_NEAR(contour.destination, Point(100, 100));
    ASSERT_FALSE(contour.is_closed);
  }
}

◆ TEST() [221/377]

impeller::testing::TEST	(	PathTest	,
		PathBuilderWillComputeBounds
	)

Definition at line 268 of file path_unittests.cc.

                                             {
  PathBuilder builder;
  auto path_1 = builder.AddLine({0, 0}, {1, 1}).TakePath();
 
  ASSERT_EQ(path_1.GetBoundingBox().value_or(Rect::MakeMaximum()),
            Rect::MakeLTRB(0, 0, 1, 1));
 
  auto path_2 = builder.AddLine({-1, -1}, {1, 1}).TakePath();
 
  // Verify that PathBuilder recomputes the bounds.
  ASSERT_EQ(path_2.GetBoundingBox().value_or(Rect::MakeMaximum()),
            Rect::MakeLTRB(-1, -1, 1, 1));
 
  // PathBuilder can set the bounds to whatever it wants
  auto path_3 = builder.AddLine({0, 0}, {1, 1})
                    .SetBounds(Rect::MakeLTRB(0, 0, 100, 100))
                    .TakePath();
 
  ASSERT_EQ(path_3.GetBoundingBox().value_or(Rect::MakeMaximum()),
            Rect::MakeLTRB(0, 0, 100, 100));
}

◆ TEST() [222/377]

impeller::testing::TEST	(	PathTest	,
		PathCreatePolyLineDoesNotDuplicatePoints
	)

Definition at line 25 of file path_unittests.cc.

                                                         {
  PathBuilder builder;
  builder.MoveTo({10, 10});
  builder.LineTo({20, 20});
  builder.LineTo({30, 30});
  builder.MoveTo({40, 40});
  builder.LineTo({50, 50});
 
  auto polyline = builder.TakePath().CreatePolyline(1.0f);
 
  ASSERT_EQ(polyline.contours.size(), 2u);
  ASSERT_EQ(polyline.points->size(), 5u);
  ASSERT_EQ(polyline.GetPoint(0).x, 10);
  ASSERT_EQ(polyline.GetPoint(1).x, 20);
  ASSERT_EQ(polyline.GetPoint(2).x, 30);
  ASSERT_EQ(polyline.GetPoint(3).x, 40);
  ASSERT_EQ(polyline.GetPoint(4).x, 50);
}

◆ TEST() [223/377]

impeller::testing::TEST	(	PathTest	,
		PathCreatePolylineGeneratesCorrectContourData
	)

Definition at line 125 of file path_unittests.cc.

                                                              {
  Path::Polyline polyline = PathBuilder{}
                                .AddLine({100, 100}, {200, 100})
                                .MoveTo({100, 200})
                                .LineTo({150, 250})
                                .LineTo({200, 200})
                                .Close()
                                .TakePath()
                                .CreatePolyline(1.0f);
  ASSERT_EQ(polyline.points->size(), 6u);
  ASSERT_EQ(polyline.contours.size(), 2u);
  ASSERT_EQ(polyline.contours[0].is_closed, false);
  ASSERT_EQ(polyline.contours[0].start_index, 0u);
  ASSERT_EQ(polyline.contours[1].is_closed, true);
  ASSERT_EQ(polyline.contours[1].start_index, 2u);
}

◆ TEST() [224/377]

impeller::testing::TEST	(	PathTest	,
		PathGetBoundingBoxForCubicWithNoDerivativeRootsIsCorrect
	)

Definition at line 372 of file path_unittests.cc.

                                                                         {
  PathBuilder builder;
  // Straight diagonal line.
  builder.AddCubicCurve({0, 1}, {2, 3}, {4, 5}, {6, 7});
  auto path = builder.TakePath();
  auto actual = path.GetBoundingBox();
  auto expected = Rect::MakeLTRB(0, 1, 6, 7);
 
  ASSERT_TRUE(actual.has_value());
  ASSERT_RECT_NEAR(actual.value_or(Rect::MakeMaximum()), expected);
}

◆ TEST() [225/377]

impeller::testing::TEST	(	PathTest	,
		PathHorizontalLine
	)

Definition at line 290 of file path_unittests.cc.

                                   {
  PathBuilder builder;
  auto path = builder.HorizontalLineTo(10).TakePath();
 
  LinearPathComponent linear;
  path.GetLinearComponentAtIndex(1, linear);
 
  EXPECT_EQ(linear.p1, Point(0, 0));
  EXPECT_EQ(linear.p2, Point(10, 0));
}

◆ TEST() [226/377]

impeller::testing::TEST	(	PathTest	,
		PathPolylineDuplicatesAreRemovedForSameContour
	)

Definition at line 176 of file path_unittests.cc.

                                                               {
  Path::Polyline polyline =
      PathBuilder{}
          .MoveTo({50, 50})
          .LineTo({50, 50})  // Insert duplicate at beginning of contour.
          .LineTo({100, 50})
          .LineTo({100, 50})  // Insert duplicate at contour join.
          .LineTo({100, 100})
          .Close()  // Implicitly insert duplicate {50, 50} across contours.
          .LineTo({0, 50})
          .LineTo({0, 100})
          .LineTo({0, 100})  // Insert duplicate at end of contour.
          .TakePath()
          .CreatePolyline(1.0f);
  ASSERT_EQ(polyline.contours.size(), 2u);
  ASSERT_EQ(polyline.contours[0].start_index, 0u);
  ASSERT_TRUE(polyline.contours[0].is_closed);
  ASSERT_EQ(polyline.contours[1].start_index, 4u);
  ASSERT_FALSE(polyline.contours[1].is_closed);
  ASSERT_EQ(polyline.points->size(), 7u);
  ASSERT_EQ(polyline.GetPoint(0), Point(50, 50));
  ASSERT_EQ(polyline.GetPoint(1), Point(100, 50));
  ASSERT_EQ(polyline.GetPoint(2), Point(100, 100));
  ASSERT_EQ(polyline.GetPoint(3), Point(50, 50));
  ASSERT_EQ(polyline.GetPoint(4), Point(50, 50));
  ASSERT_EQ(polyline.GetPoint(5), Point(0, 50));
  ASSERT_EQ(polyline.GetPoint(6), Point(0, 100));
}

◆ TEST() [227/377]

impeller::testing::TEST	(	PathTest	,
		PathShifting
	)

Definition at line 232 of file path_unittests.cc.

                             {
  PathBuilder builder{};
  auto path =
      builder.AddLine(Point(0, 0), Point(10, 10))
          .AddQuadraticCurve(Point(10, 10), Point(15, 15), Point(20, 20))
          .AddCubicCurve(Point(20, 20), Point(25, 25), Point(-5, -5),
                         Point(30, 30))
          .Close()
          .Shift(Point(1, 1))
          .TakePath();
 
  ContourComponent contour;
  LinearPathComponent linear;
  QuadraticPathComponent quad;
  CubicPathComponent cubic;
 
  ASSERT_TRUE(path.GetContourComponentAtIndex(0, contour));
  ASSERT_TRUE(path.GetLinearComponentAtIndex(1, linear));
  ASSERT_TRUE(path.GetQuadraticComponentAtIndex(3, quad));
  ASSERT_TRUE(path.GetCubicComponentAtIndex(5, cubic));
 
  EXPECT_EQ(contour.destination, Point(1, 1));
 
  EXPECT_EQ(linear.p1, Point(1, 1));
  EXPECT_EQ(linear.p2, Point(11, 11));
 
  EXPECT_EQ(quad.cp, Point(16, 16));
  EXPECT_EQ(quad.p1, Point(11, 11));
  EXPECT_EQ(quad.p2, Point(21, 21));
 
  EXPECT_EQ(cubic.cp1, Point(26, 26));
  EXPECT_EQ(cubic.cp2, Point(-4, -4));
  EXPECT_EQ(cubic.p1, Point(21, 21));
  EXPECT_EQ(cubic.p2, Point(31, 31));
}

◆ TEST() [228/377]

impeller::testing::TEST	(	PathTest	,
		PathVerticalLine
	)

Definition at line 301 of file path_unittests.cc.

                                 {
  PathBuilder builder;
  auto path = builder.VerticalLineTo(10).TakePath();
 
  LinearPathComponent linear;
  path.GetLinearComponentAtIndex(1, linear);
 
  EXPECT_EQ(linear.p1, Point(0, 0));
  EXPECT_EQ(linear.p2, Point(0, 10));
}

◆ TEST() [229/377]

impeller::testing::TEST	(	PathTest	,
		PolylineBufferReuse
	)

Definition at line 205 of file path_unittests.cc.

                                    {
  auto point_buffer = std::make_unique<std::vector<Point>>();
  auto point_buffer_address = reinterpret_cast<uintptr_t>(point_buffer.get());
  Path::Polyline polyline =
      PathBuilder{}
          .MoveTo({50, 50})
          .LineTo({100, 100})
          .TakePath()
          .CreatePolyline(
              1.0f, std::move(point_buffer),
              [point_buffer_address](
                  Path::Polyline::PointBufferPtr point_buffer) {
                ASSERT_EQ(point_buffer->size(), 0u);
                ASSERT_EQ(point_buffer_address,
                          reinterpret_cast<uintptr_t>(point_buffer.get()));
              });
}

◆ TEST() [230/377]

impeller::testing::TEST	(	PathTest	,
		PolylineFailsWithNullptrBuffer
	)

Definition at line 223 of file path_unittests.cc.

                                               {
  EXPECT_DEATH_IF_SUPPORTED(PathBuilder{}
                                .MoveTo({50, 50})
                                .LineTo({100, 100})
                                .TakePath()
                                .CreatePolyline(1.0f, nullptr),
                            "");
}

◆ TEST() [231/377]

impeller::testing::TEST	(	PathTest	,
		PolylineGetContourPointBoundsReturnsCorrectRanges
	)

Definition at line 142 of file path_unittests.cc.

                                                                  {
  Path::Polyline polyline = PathBuilder{}
                                .AddLine({100, 100}, {200, 100})
                                .MoveTo({100, 200})
                                .LineTo({150, 250})
                                .LineTo({200, 200})
                                .Close()
                                .TakePath()
                                .CreatePolyline(1.0f);
  size_t a1, a2, b1, b2;
  std::tie(a1, a2) = polyline.GetContourPointBounds(0);
  std::tie(b1, b2) = polyline.GetContourPointBounds(1);
  ASSERT_EQ(a1, 0u);
  ASSERT_EQ(a2, 2u);
  ASSERT_EQ(b1, 2u);
  ASSERT_EQ(b2, 6u);
}

◆ TEST() [232/377]

impeller::testing::TEST	(	PathTest	,
		QuadradicPath
	)

Definition at line 312 of file path_unittests.cc.

                              {
  PathBuilder builder;
  auto path = builder.QuadraticCurveTo(Point(10, 10), Point(20, 20)).TakePath();
 
  QuadraticPathComponent quad;
  path.GetQuadraticComponentAtIndex(1, quad);
 
  EXPECT_EQ(quad.p1, Point(0, 0));
  EXPECT_EQ(quad.cp, Point(10, 10));
  EXPECT_EQ(quad.p2, Point(20, 20));
}

◆ TEST() [233/377]

impeller::testing::TEST	(	PathTest	,
		RepeatCloseDoesNotAddNewLines
	)

Definition at line 457 of file path_unittests.cc.

                                              {
  PathBuilder builder;
  auto path = builder.LineTo({0, 10})
                  .LineTo({10, 10})
                  .Close()  // Returns to (0, 0)
                  .Close()  // No Op
                  .Close()  // Still No op
                  .TakePath();
 
  EXPECT_EQ(path.GetComponentCount(), 5u);
  EXPECT_EQ(path.GetComponentCount(Path::ComponentType::kLinear), 3u);
  EXPECT_EQ(path.GetComponentCount(Path::ComponentType::kContour), 2u);
}

◆ TEST() [234/377]

impeller::testing::TEST	(	PathTest	,
		SimplePath
	)

Definition at line 397 of file path_unittests.cc.

                           {
  PathBuilder builder;
 
  auto path = builder.AddLine({0, 0}, {100, 100})
                  .AddQuadraticCurve({100, 100}, {200, 200}, {300, 300})
                  .AddCubicCurve({300, 300}, {400, 400}, {500, 500}, {600, 600})
                  .TakePath();
 
  ASSERT_EQ(path.GetComponentCount(), 6u);
  ASSERT_EQ(path.GetComponentCount(Path::ComponentType::kLinear), 1u);
  ASSERT_EQ(path.GetComponentCount(Path::ComponentType::kQuadratic), 1u);
  ASSERT_EQ(path.GetComponentCount(Path::ComponentType::kCubic), 1u);
  ASSERT_EQ(path.GetComponentCount(Path::ComponentType::kContour), 3u);
 
  path.EnumerateComponents(
      [](size_t index, const LinearPathComponent& linear) {
        Point p1(0, 0);
        Point p2(100, 100);
        ASSERT_EQ(index, 1u);
        ASSERT_EQ(linear.p1, p1);
        ASSERT_EQ(linear.p2, p2);
      },
      [](size_t index, const QuadraticPathComponent& quad) {
        Point p1(100, 100);
        Point cp(200, 200);
        Point p2(300, 300);
        ASSERT_EQ(index, 3u);
        ASSERT_EQ(quad.p1, p1);
        ASSERT_EQ(quad.cp, cp);
        ASSERT_EQ(quad.p2, p2);
      },
      [](size_t index, const CubicPathComponent& cubic) {
        Point p1(300, 300);
        Point cp1(400, 400);
        Point cp2(500, 500);
        Point p2(600, 600);
        ASSERT_EQ(index, 5u);
        ASSERT_EQ(cubic.p1, p1);
        ASSERT_EQ(cubic.cp1, cp1);
        ASSERT_EQ(cubic.cp2, cp2);
        ASSERT_EQ(cubic.p2, p2);
      },
      [](size_t index, const ContourComponent& contour) {
        // There is an initial countour added for each curve.
        if (index == 0u) {
          Point p1(0, 0);
          ASSERT_EQ(contour.destination, p1);
        } else if (index == 2u) {
          Point p1(100, 100);
          ASSERT_EQ(contour.destination, p1);
        } else if (index == 4u) {
          Point p1(300, 300);
          ASSERT_EQ(contour.destination, p1);
        } else {
          ASSERT_FALSE(true);
        }
        ASSERT_FALSE(contour.is_closed);
      });
}

◆ TEST() [235/377]

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

◆ TEST() [236/377]

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

◆ TEST() [237/377]

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

◆ TEST() [238/377]

impeller::testing::TEST	(	ProcTableGLES	,
		ResolvesCorrectClearDepthProcOnDesktopGL
	)

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

◆ TEST() [239/377]

impeller::testing::TEST	(	ProcTableGLES	,
		ResolvesCorrectClearDepthProcOnES
	)

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

◆ TEST() [240/377]

impeller::testing::TEST	(	RectTest	,
		ContainsFloatingPoint
	)

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

◆ TEST() [241/377]

impeller::testing::TEST	(	RectTest	,
		EmptyIRectDoesNotIntersect
	)

Definition at line 854 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");
}

◆ TEST() [242/377]

impeller::testing::TEST	(	RectTest	,
		EmptyRectDoesNotIntersect
	)

Definition at line 824 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");
}

◆ TEST() [243/377]

impeller::testing::TEST	(	RectTest	,
		GetCenter
	)

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

◆ TEST() [244/377]

impeller::testing::TEST	(	RectTest	,
		IRectArea
	)

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

◆ TEST() [245/377]

impeller::testing::TEST	(	RectTest	,
		IRectContainsInclusiveIPoint
	)

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

◆ TEST() [246/377]

impeller::testing::TEST	(	RectTest	,
		IRectContainsIPoint
	)

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

◆ TEST() [247/377]

impeller::testing::TEST	(	RectTest	,
		IRectContainsIRect
	)

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

◆ TEST() [248/377]

impeller::testing::TEST	(	RectTest	,
		IRectCopy
	)

Definition at line 641 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());
}

◆ TEST() [249/377]

impeller::testing::TEST	(	RectTest	,
		IRectCutOut
	)

Definition at line 2791 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");
}

◆ TEST() [250/377]

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

◆ TEST() [251/377]

impeller::testing::TEST	(	RectTest	,
		IRectDoesNotIntersectEmpty
	)

Definition at line 794 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");
}

◆ TEST() [252/377]

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
}

◆ TEST() [253/377]

impeller::testing::TEST	(	RectTest	,
		IRectExpand
	)

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

◆ TEST() [254/377]

impeller::testing::TEST	(	RectTest	,
		IRectFromIRect
	)

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

◆ TEST() [255/377]

impeller::testing::TEST	(	RectTest	,
		IRectGetNormalizingTransform
	)

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

◆ TEST() [256/377]

impeller::testing::TEST	(	RectTest	,
		IRectIntersection
	)

Definition at line 1751 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());
  }
}

◆ TEST() [257/377]

impeller::testing::TEST	(	RectTest	,
		IRectIntersectsWithRect
	)

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

◆ TEST() [258/377]

impeller::testing::TEST	(	RectTest	,
		IRectMakeMaximum
	)

Definition at line 593 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());
}

◆ TEST() [259/377]

impeller::testing::TEST	(	RectTest	,
		IRectOriginSizeXYWHGetters
	)

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

◆ TEST() [260/377]

impeller::testing::TEST	(	RectTest	,
		IRectOverflowLTRB
	)

Definition at line 478 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());
  }
}

◆ TEST() [261/377]

impeller::testing::TEST	(	RectTest	,
		IRectOverflowXYWH
	)

Definition at line 272 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());
  }
}

◆ TEST() [262/377]

impeller::testing::TEST	(	RectTest	,
		IRectRound
	)

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

◆ TEST() [263/377]

impeller::testing::TEST	(	RectTest	,
		IRectRoundOut
	)

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

◆ TEST() [264/377]

impeller::testing::TEST	(	RectTest	,
		IRectScale
	)

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

◆ TEST() [265/377]

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

◆ TEST() [266/377]

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

◆ TEST() [267/377]

impeller::testing::TEST	(	RectTest	,
		IRectUnion
	)

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

◆ TEST() [268/377]

impeller::testing::TEST	(	RectTest	,
		IRectXYWHIsEmpty
	)

Definition at line 1151 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());
}

◆ TEST() [269/377]

impeller::testing::TEST	(	RectTest	,
		IsSquare
	)

Definition at line 1182 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());
}

◆ TEST() [270/377]

impeller::testing::TEST	(	RectTest	,
		MakePointBoundsQuad
	)

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

◆ TEST() [271/377]

impeller::testing::TEST	(	RectTest	,
		OptIRectIntersection
	)

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

◆ TEST() [272/377]

impeller::testing::TEST	(	RectTest	,
		OptIRectUnion
	)

Definition at line 1528 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_TRUE(IRect::Union(r, std::nullopt).has_value());
    EXPECT_EQ(IRect::Union(r, std::nullopt).value(), 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_TRUE(IRect::Union(std::nullopt, r).has_value());
    EXPECT_EQ(IRect::Union(std::nullopt, r).value(), 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_TRUE(IRect::Union(a, std::optional(b)).has_value());
    EXPECT_EQ(IRect::Union(a, std::optional(b)).value(), u);
 
    // OptRect, Rect
    EXPECT_TRUE(IRect::Union(std::optional(a), b).has_value());
    EXPECT_EQ(IRect::Union(std::optional(a), b).value(), 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));
}

◆ TEST() [273/377]

impeller::testing::TEST	(	RectTest	,
		OptRectIntersection
	)

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

◆ TEST() [274/377]

impeller::testing::TEST	(	RectTest	,
		OptRectUnion
	)

Definition at line 1404 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_TRUE(Rect::Union(r, std::nullopt).has_value());
    EXPECT_EQ(Rect::Union(r, std::nullopt).value(), 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_TRUE(Rect::Union(std::nullopt, r).has_value());
    EXPECT_EQ(Rect::Union(std::nullopt, r).value(), 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_TRUE(Rect::Union(a, std::optional(b)).has_value());
    EXPECT_EQ(Rect::Union(a, std::optional(b)).value(), u);
 
    // OptRect, Rect
    EXPECT_TRUE(Rect::Union(std::optional(a), b).has_value());
    EXPECT_EQ(Rect::Union(std::optional(a), b).value(), 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));
}

◆ TEST() [275/377]

impeller::testing::TEST	(	RectTest	,
		RectArea
	)

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

◆ TEST() [276/377]

impeller::testing::TEST	(	RectTest	,
		RectContainsInclusivePoint
	)

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

◆ TEST() [277/377]

impeller::testing::TEST	(	RectTest	,
		RectContainsPoint
	)

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

◆ TEST() [278/377]

impeller::testing::TEST	(	RectTest	,
		RectContainsRect
	)

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

◆ TEST() [279/377]

impeller::testing::TEST	(	RectTest	,
		RectCopy
	)

Definition at line 623 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());
}

◆ TEST() [280/377]

impeller::testing::TEST	(	RectTest	,
		RectCutOut
	)

Definition at line 2639 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");
}

◆ TEST() [281/377]

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() [282/377]

impeller::testing::TEST	(	RectTest	,
		RectDirections
	)

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

◆ TEST() [283/377]

impeller::testing::TEST	(	RectTest	,
		RectDoesNotIntersectEmpty
	)

Definition at line 764 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");
}

◆ TEST() [284/377]

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() [285/377]

impeller::testing::TEST	(	RectTest	,
		RectExpand
	)

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

◆ TEST() [286/377]

impeller::testing::TEST	(	RectTest	,
		RectFromRect
	)

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

◆ TEST() [287/377]

impeller::testing::TEST	(	RectTest	,
		RectGetNormalizingTransform
	)

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

◆ TEST() [288/377]

impeller::testing::TEST	(	RectTest	,
		RectGetPoints
	)

Definition at line 2910 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()));
  }
}

◆ TEST() [289/377]

impeller::testing::TEST	(	RectTest	,
		RectGetPositive
	)

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

◆ TEST() [290/377]

impeller::testing::TEST	(	RectTest	,
		RectGetTransformedPoints
	)

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

◆ TEST() [291/377]

impeller::testing::TEST	(	RectTest	,
		RectIntersection
	)

Definition at line 1580 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_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_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_FALSE(b.Intersection(a).has_value()) << 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());
  }
}

◆ TEST() [292/377]

impeller::testing::TEST	(	RectTest	,
		RectIntersectsWithRect
	)

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

◆ TEST() [293/377]

impeller::testing::TEST	(	RectTest	,
		RectMakeMaximum
	)

Definition at line 575 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());
}

◆ TEST() [294/377]

impeller::testing::TEST	(	RectTest	,
		RectMakePointBounds
	)

Definition at line 2950 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());
  }
}

◆ TEST() [295/377]

impeller::testing::TEST	(	RectTest	,
		RectMakeSize
	)

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

◆ TEST() [296/377]

impeller::testing::TEST	(	RectTest	,
		RectOriginSizeXYWHGetters
	)

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

◆ TEST() [297/377]

impeller::testing::TEST	(	RectTest	,
		RectOverflowLTRB
	)

Definition at line 339 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());
  }
}

◆ TEST() [298/377]

impeller::testing::TEST	(	RectTest	,
		RectOverflowXYWH
	)

Definition at line 133 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());
  }
}

◆ TEST() [299/377]

impeller::testing::TEST	(	RectTest	,
		RectProject
	)

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

◆ TEST() [300/377]

impeller::testing::TEST	(	RectTest	,
		RectRound
	)

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

◆ TEST() [301/377]

impeller::testing::TEST	(	RectTest	,
		RectRoundOut
	)

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

◆ TEST() [302/377]

impeller::testing::TEST	(	RectTest	,
		RectRoundOutEmpty
	)

Definition at line 709 of file rect_unittests.cc.

                                  {
  Rect rect;
 
  EXPECT_EQ(Rect::RoundOut(rect), Rect());
 
  EXPECT_EQ(IRect::RoundOut(rect), IRect());
}

◆ TEST() [303/377]

impeller::testing::TEST	(	RectTest	,
		RectRoundOutSimple
	)

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

◆ TEST() [304/377]

impeller::testing::TEST	(	RectTest	,
		RectRoundOutToIRectHuge
	)

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

◆ TEST() [305/377]

impeller::testing::TEST	(	RectTest	,
		RectScale
	)

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

◆ TEST() [306/377]

impeller::testing::TEST	(	RectTest	,
		RectShift
	)

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

◆ TEST() [307/377]

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

◆ TEST() [308/377]

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

◆ TEST() [309/377]

impeller::testing::TEST	(	RectTest	,
		RectUnion
	)

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

◆ TEST() [310/377]

impeller::testing::TEST	(	RectTest	,
		RectXYWHIsEmpty
	)

Definition at line 1127 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());
}

◆ TEST() [311/377]

impeller::testing::TEST	(	RectTest	,
		TransformAndClipBounds
	)

Definition at line 3067 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);
  }
 
  {
    // 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
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                        Vector3(200.0f, 200.0f, 1.4f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                        Vector3(400.0f, 200.0f, 0.4f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                        Vector3(200.0f, 400.0f, 0.8f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                        Vector3(400.0f, 400.0f, -0.2f));
 
    Rect expect = Rect::MakeLTRB(142.85715f, 142.85715f, 6553600.f, 6553600.f);
    EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
    EXPECT_RECT_NEAR(src.TransformAndClipBounds(matrix), expect);
  }
 
  {
    // 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 should have a W<0
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                        Vector3(200.0f, 200.0f, 0.9f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                        Vector3(400.0f, 200.0f, -0.6f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                        Vector3(200.0f, 400.0f, 0.3f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                        Vector3(400.0f, 400.0f, -1.2f));
 
    Rect expect = Rect::MakeLTRB(222.2222f, 222.2222f, 5898373.f, 6553600.f);
    EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
    EXPECT_RECT_NEAR(src.TransformAndClipBounds(matrix), expect);
  }
 
  {
    // 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 should have a W<0
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                        Vector3(200.0f, 200.0f, 0.4f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                        Vector3(400.0f, 200.0f, -1.6f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                        Vector3(200.0f, 400.0f, -0.2f));
    EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                        Vector3(400.0f, 400.0f, -2.2f));
 
    Rect expect = Rect::MakeLTRB(499.99988f, 499.99988f, 5898340.f, 4369400.f);
    EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
    EXPECT_RECT_NEAR(src.TransformAndClipBounds(matrix), expect);
  }
 
  {
    // 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
    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());
  }
}

◆ TEST() [312/377]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesMSAAResolveWithCorrectStore
	)

Definition at line 102 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.GetColorAttachments().find(0u);
  ASSERT_NE(maybe_color, builder.GetColorAttachments().end());
  auto color = maybe_color->second;
 
  // MSAA Texture.
  EXPECT_EQ(color.initialLayout, vk::ImageLayout::eGeneral);
  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.GetResolves().find(0u);
  ASSERT_NE(maybe_resolve, builder.GetResolves().end());
  auto resolve = maybe_resolve->second;
 
  // MSAA Resolve Texture.
  EXPECT_EQ(resolve.initialLayout, vk::ImageLayout::eGeneral);
  EXPECT_EQ(resolve.finalLayout, vk::ImageLayout::eGeneral);
  EXPECT_EQ(resolve.loadOp, vk::AttachmentLoadOp::eClear);
  EXPECT_EQ(resolve.storeOp, vk::AttachmentStoreOp::eStore);
}

◆ TEST() [313/377]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesRenderPassWithCombinedDepthStencil
	)

Definition at line 30 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.SetDepthStencilAttachment(PixelFormat::kD24UnormS8Uint,
                                    SampleCount::kCount1, LoadAction::kDontCare,
                                    StoreAction::kDontCare);
 
  auto render_pass = builder.Build(context->GetDevice());
 
  EXPECT_TRUE(!!render_pass);
 
  auto maybe_color = builder.GetColorAttachments().find(0u);
  ASSERT_NE(maybe_color, builder.GetColorAttachments().end());
  auto color = maybe_color->second;
 
  EXPECT_EQ(color.initialLayout, vk::ImageLayout::eGeneral);
  EXPECT_EQ(color.finalLayout, vk::ImageLayout::eGeneral);
  EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eClear);
  EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eStore);
 
  auto maybe_depth_stencil = builder.GetDepthStencil();
  ASSERT_TRUE(maybe_depth_stencil.has_value());
  if (!maybe_depth_stencil.has_value()) {
    return;
  }
  auto 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);
}

◆ TEST() [314/377]

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

◆ TEST() [315/377]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesRenderPassWithOnlyStencil
	)

Definition at line 71 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);
 
  auto maybe_depth_stencil = builder.GetDepthStencil();
  ASSERT_TRUE(maybe_depth_stencil.has_value());
  if (!maybe_depth_stencil.has_value()) {
    return;
  }
  auto 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);
}

◆ TEST() [316/377]

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

◆ TEST() [317/377]

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

◆ TEST() [318/377]

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

◆ TEST() [319/377]

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

◆ TEST() [320/377]

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() [321/377]

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() [322/377]

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() [323/377]

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() [324/377]

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() [325/377]

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() [326/377]

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() [327/377]

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() [328/377]

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() [329/377]

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() [330/377]

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() [331/377]

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() [332/377]

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() [333/377]

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() [334/377]

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() [335/377]

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() [336/377]

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() [337/377]

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() [338/377]

impeller::testing::TEST	(	ShaderArchiveTest	,
		CanReadAndWriteBlobs
	)

Definition at line 28 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);
 
  ShaderArchive library(mapping);
  ASSERT_TRUE(library.IsValid());
  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");
}

◆ TEST() [339/377]

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() [340/377]

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() [341/377]

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() [342/377]

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() [343/377]

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() [344/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		GradientConversionNonMonotonic
	)

Definition at line 151 of file skia_conversions_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(SkPoint::Make(0, 0),          //
                                         SkPoint::Make(1.0, 1.0),      //
                                         4,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  skia_conversions::ConvertStops(gradient.get(), 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));
}

◆ TEST() [345/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		GradientMissing0
	)

Definition at line 73 of file skia_conversions_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(SkPoint::Make(0, 0),          //
                                         SkPoint::Make(1.0, 1.0),      //
                                         2,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  skia_conversions::ConvertStops(gradient.get(), 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));
}

◆ TEST() [346/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		GradientMissingLastValue
	)

Definition at line 99 of file skia_conversions_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(SkPoint::Make(0, 0),          //
                                         SkPoint::Make(1.0, 1.0),      //
                                         2,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  skia_conversions::ConvertStops(gradient.get(), 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));
}

◆ TEST() [347/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		GradientStopConversion
	)

Definition at line 47 of file skia_conversions_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(SkPoint::Make(0, 0),          //
                                         SkPoint::Make(1.0, 1.0),      //
                                         3,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  skia_conversions::ConvertStops(gradient.get(), 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));
}

◆ TEST() [348/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		GradientStopGreaterThan1
	)

Definition at line 125 of file skia_conversions_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(SkPoint::Make(0, 0),          //
                                         SkPoint::Make(1.0, 1.0),      //
                                         3,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  skia_conversions::ConvertStops(gradient.get(), 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));
}

◆ TEST() [349/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		IsNearlySimpleRRect
	)

Definition at line 178 of file skia_conversions_unittests.cc.

                                               {
  EXPECT_TRUE(skia_conversions::IsNearlySimpleRRect(
      SkRRect::MakeRectXY(SkRect::MakeLTRB(0, 0, 10, 10), 10, 10)));
  EXPECT_TRUE(skia_conversions::IsNearlySimpleRRect(
      SkRRect::MakeRectXY(SkRect::MakeLTRB(0, 0, 10, 10), 10, 9.999)));
  EXPECT_FALSE(skia_conversions::IsNearlySimpleRRect(
      SkRRect::MakeRectXY(SkRect::MakeLTRB(0, 0, 10, 10), 10, 9)));
}

◆ TEST() [350/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		SkPointToPoint
	)

Definition at line 15 of file skia_conversions_unittests.cc.

                                          {
  for (int x = -100; x < 100; x += 4) {
    for (int y = -100; y < 100; y += 4) {
      EXPECT_EQ(skia_conversions::ToPoint(SkPoint::Make(x * 0.25f, y * 0.25f)),
                Point(x * 0.25f, y * 0.25f));
    }
  }
}

◆ TEST() [351/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		SkPointToSize
	)

Definition at line 24 of file skia_conversions_unittests.cc.

                                         {
  for (int x = -100; x < 100; x += 4) {
    for (int y = -100; y < 100; y += 4) {
      EXPECT_EQ(skia_conversions::ToSize(SkPoint::Make(x * 0.25f, y * 0.25f)),
                Size(x * 0.25f, y * 0.25f));
    }
  }
}

◆ TEST() [352/377]

impeller::testing::TEST	(	SkiaConversionsTest	,
		ToColor
	)

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

◆ TEST() [353/377]

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

◆ TEST() [354/377]

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

◆ TEST() [355/377]

impeller::testing::TEST	(	StringsTest	,
		CanSPrintF
	)

Definition at line 86 of file base_unittests.cc.

                              {
  ASSERT_EQ(SPrintF("%sx%d", "Hello", 12), "Hellox12");
  ASSERT_EQ(SPrintF(""), "");
  ASSERT_EQ(SPrintF("Hello"), "Hello");
  ASSERT_EQ(SPrintF("%sx%.2f", "Hello", 12.122222), "Hellox12.12");
}

◆ TEST() [356/377]

impeller::testing::TEST	(	SwapchainTest	,
		CachesRenderPassOnSwapchainImage
	)

Definition at line 59 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->GetTargetRenderPassDescriptor();
 
    auto texture = render_target.GetRenderTargetTexture();
    auto& texture_vk = TextureVK::Cast(*texture);
    EXPECT_EQ(texture_vk.GetCachedFramebuffer(), nullptr);
    EXPECT_EQ(texture_vk.GetCachedRenderPass(), 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.GetColorAttachments().find(0u)->second.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->GetTargetRenderPassDescriptor();
 
    auto texture = render_target.GetRenderTargetTexture();
    auto& texture_vk = TextureVK::Cast(*texture);
 
    EXPECT_NE(texture_vk.GetCachedFramebuffer(), nullptr);
    EXPECT_NE(texture_vk.GetCachedRenderPass(), nullptr);
    framebuffers.push_back(texture_vk.GetCachedFramebuffer());
    render_passes.push_back(texture_vk.GetCachedRenderPass());
  }
 
  // 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->GetTargetRenderPassDescriptor();
 
    auto texture = render_target.GetRenderTargetTexture();
    auto& texture_vk = TextureVK::Cast(*texture);
 
    EXPECT_EQ(texture_vk.GetCachedFramebuffer(), framebuffers[i]);
    EXPECT_EQ(texture_vk.GetCachedRenderPass(), render_passes[i]);
  }
}

◆ TEST() [357/377]

impeller::testing::TEST	(	SwapchainTest	,
		CanCreateSwapchain
	)

Definition at line 29 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());
}

◆ TEST() [358/377]

impeller::testing::TEST	(	SwapchainTest	,
		RecreateSwapchainWhenSizeChanges
	)

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

◆ TEST() [359/377]

impeller::testing::TEST	(	TessellatorTest	,
		ChecksConcurrentPolylineUsage
	)

Definition at line 515 of file tessellator_unittests.cc.

                                                     {
  auto tessellator = std::make_shared<Tessellator>();
  PathBuilder builder;
  builder.AddLine({0, 0}, {100, 100});
  auto path = builder.TakePath();
 
  auto polyline = tessellator->CreateTempPolyline(path, 0.1);
  EXPECT_DEBUG_DEATH(tessellator->CreateTempPolyline(path, 0.1),
                     "point_buffer_");
}

◆ TEST() [360/377]

impeller::testing::TEST	(	TessellatorTest	,
		CircleVertexCounts
	)

Definition at line 139 of file tessellator_unittests.cc.

                                          {
  auto tessellator = std::make_shared<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);
  }
}

◆ TEST() [361/377]

impeller::testing::TEST	(	TessellatorTest	,
		EarlyReturnEmptyConvexShape
	)

Definition at line 499 of file tessellator_unittests.cc.

                                                   {
  // This path is not technically empty (it has a size in one dimension),
  // but is otherwise completely flat.
  PathBuilder builder;
  builder.MoveTo({0, 0});
  builder.MoveTo({10, 10}, /*relative=*/true);
 
  std::vector<Point> points;
  std::vector<uint16_t> indices;
  Tessellator::TessellateConvexInternal(builder.TakePath(), points, indices,
                                        3.0);
 
  EXPECT_TRUE(points.empty());
}

◆ TEST() [362/377]

impeller::testing::TEST	(	TessellatorTest	,
		FilledCircleTessellationVertices
	)

Definition at line 175 of file tessellator_unittests.cc.

                                                        {
  auto tessellator = std::make_shared<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);
}

◆ TEST() [363/377]

impeller::testing::TEST	(	TessellatorTest	,
		FilledEllipseTessellationVertices
	)

Definition at line 364 of file tessellator_unittests.cc.

                                                         {
  auto tessellator = std::make_shared<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));
}

◆ TEST() [364/377]

impeller::testing::TEST	(	TessellatorTest	,
		FilledRoundRectTessellationVertices
	)

Definition at line 425 of file tessellator_unittests.cc.

                                                           {
  auto tessellator = std::make_shared<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});
}

◆ TEST() [365/377]

impeller::testing::TEST	(	TessellatorTest	,
		RoundCapLineTessellationVertices
	)

Definition at line 291 of file tessellator_unittests.cc.

                                                        {
  auto tessellator = std::make_shared<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);
}

◆ TEST() [366/377]

impeller::testing::TEST	(	TessellatorTest	,
		StrokedCircleTessellationVertices
	)

Definition at line 219 of file tessellator_unittests.cc.

                                                         {
  auto tessellator = std::make_shared<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);
}

◆ TEST() [367/377]

impeller::testing::TEST	(	TessellatorTest	,
		TessellateConvex
	)

Definition at line 84 of file tessellator_unittests.cc.

                                        {
  {
    std::vector<Point> points;
    std::vector<uint16_t> indices;
    // Sanity check simple rectangle.
    Tessellator::TessellateConvexInternal(
        PathBuilder{}.AddRect(Rect::MakeLTRB(0, 0, 10, 10)).TakePath(), 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(
        PathBuilder{}
            .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);
  }
}

◆ TEST() [368/377]

impeller::testing::TEST	(	TessellatorTest	,
		TessellateConvexUnclosedPath
	)

Definition at line 121 of file tessellator_unittests.cc.

                                                    {
  std::vector<Point> points;
  std::vector<uint16_t> indices;
 
  // Create a rectangle that lacks an explicit close.
  Path path = PathBuilder{}
                  .LineTo({100, 0})
                  .LineTo({100, 100})
                  .LineTo({0, 100})
                  .TakePath();
  Tessellator::TessellateConvexInternal(path, points, indices, 1.0);
 
  std::vector<Point> expected = {{0, 0}, {100, 0}, {100, 100}, {0, 100}};
  std::vector<uint16_t> expected_indices = {0, 1, 3, 2};
  EXPECT_EQ(points, expected);
  EXPECT_EQ(indices, expected_indices);
}

◆ TEST() [369/377]

impeller::testing::TEST	(	TessellatorTest	,
		TessellatorBuilderReturnsCorrectResultStatus
	)

Definition at line 17 of file tessellator_unittests.cc.

                                                                    {
  // Zero points.
  {
    TessellatorLibtess t;
    auto path = PathBuilder{}.TakePath(FillType::kOdd);
    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 = PathBuilder{}.LineTo({0, 0}).TakePath(FillType::kOdd);
    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 = PathBuilder{}.AddLine({0, 0}, {0, 1}).TakePath(FillType::kOdd);
    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;
    PathBuilder builder;
    for (int i = 0; i < 1000; i++) {
      auto coord = i * 1.0f;
      builder.AddLine({coord, coord}, {coord + 1, coord + 1});
    }
    auto path = builder.TakePath(FillType::kOdd);
    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 = PathBuilder{}.AddLine({0, 0}, {0, 1}).TakePath(FillType::kOdd);
    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);
  }
}

◆ TEST() [370/377]

impeller::testing::TEST	(	TextureMTL	,
		CreateFromDrawable
	)

Definition at line 21 of file texture_mtl_unittests.mm.

                                     {
  auto device = MTLCreateSystemDefaultDevice();
  auto layer = [[CAMetalLayer alloc] init];
  layer.device = device;
  layer.drawableSize = CGSize{100, 100};
  layer.pixelFormat = ToMTLPixelFormat(PixelFormat::kB8G8R8A8UNormInt);
 
  TextureDescriptor desc;
  desc.size = {100, 100};
  desc.format = PixelFormat::kB8G8R8A8UNormInt;
  auto drawable_future = GetDrawableDeferred(layer);
  auto drawable_texture =
      CreateTextureFromDrawableFuture(desc, drawable_future);
 
  ASSERT_TRUE(drawable_texture->IsValid());
  EXPECT_TRUE(drawable_texture->IsDrawable());
 
  // Spawn a thread and acquire the drawable in the thread.
  auto thread = std::thread([&drawable_texture]() {
    // Force the drawable to be acquired.
    drawable_texture->GetMTLTexture();
  });
  thread.join();
  // Block until drawable is acquired.
  EXPECT_TRUE(drawable_future.get() != nil);
  // Drawable is cached.
  EXPECT_TRUE(drawable_texture->GetMTLTexture() != nil);
  // Once more for good measure.
  EXPECT_TRUE(drawable_texture->GetMTLTexture() != nil);
}

◆ TEST() [371/377]

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

◆ TEST() [372/377]

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

◆ TEST() [373/377]

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();
  int b = f.a;  // NOLINT(clang-analyzer-deadcode.DeadStores)
  FML_ALLOW_UNUSED_LOCAL(b);
  f.mtx.UnlockReader();
}

◆ TEST() [374/377]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateRWMutexLock
	)

Definition at line 67 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);
    int b = f.a;  // NOLINT(clang-analyzer-deadcode.DeadStores)
    FML_ALLOW_UNUSED_LOCAL(b);
  }
 
  // f.mtx.UnlockReader(); <--- Static analysis error.
}

◆ TEST() [375/377]

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

◆ TEST() [376/377]

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

◆ TEST() [377/377]

impeller::testing::TEST	(	TypographerTest	,
		RectanglePackerFillsRows
	)

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

◆ TEST_F()

impeller::testing::TEST_F	(	GoldenTests	,
		ConicalGradient
	)

Definition at line 72 of file golden_tests.cc.

                                     {
  Canvas canvas;
  Paint paint;
 
  paint.color_source = ColorSource::MakeConicalGradient(
      {125, 125}, 125, {Color(1.0, 0.0, 0.0, 1.0), Color(0.0, 0.0, 1.0, 1.0)},
      {0, 1}, {180, 180}, 0, Entity::TileMode::kClamp, {});
 
  paint.stroke_width = 0.0;
  paint.style = Paint::Style::kFill;
  canvas.DrawRect(Rect::MakeXYWH(10, 10, 250, 250), paint);
  Picture picture = canvas.EndRecordingAsPicture();
 
  auto aiks_context =
      AiksContext(Screenshotter().GetPlayground().GetContext(), nullptr);
  auto screenshot = Screenshotter().MakeScreenshot(aiks_context, picture);
  ASSERT_TRUE(SaveScreenshot(std::move(screenshot)));
}

◆ TEST_P() [1/450]

impeller::testing::TEST_P	(	AiksTest	,
		ArcWithZeroSweepAndBlur
	)

Definition at line 371 of file aiks_path_unittests.cc.

                                          {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  Paint paint;
  paint.color = Color::Red();
  std::vector<Color> colors = {Color{1.0, 0.0, 0.0, 1.0},
                               Color{0.0, 0.0, 0.0, 1.0}};
  std::vector<Scalar> stops = {0.0, 1.0};
  paint.color_source = ColorSource::MakeSweepGradient(
      {100, 100}, Degrees(45), Degrees(135), std::move(colors),
      std::move(stops), Entity::TileMode::kMirror, {});
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kNormal,
      .sigma = Sigma(20),
  };
 
  PathBuilder builder;
  builder.AddArc(Rect::MakeXYWH(10, 10, 100, 100), Degrees(0), Degrees(0),
                 false);
  canvas.DrawPath(builder.TakePath(), paint);
 
  // Check that this empty picture can be created without crashing.
  canvas.EndRecordingAsPicture();
}

◆ TEST_P() [2/450]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModePlusAlphaColorFilterWideGamut
	)

Definition at line 157 of file aiks_blend_unittests.cc.

                                                         {
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.DrawPaint({.color = Color(0.1, 0.2, 0.1, 1.0)});
  canvas.SaveLayer({
      .color_filter =
          ColorFilter::MakeBlend(BlendMode::kPlus, Color(Vector4{1, 0, 0, 1})),
  });
  Paint paint;
  paint.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 400, 400), paint);
  paint.color = Color::White();
  canvas.DrawImageRect(
      std::make_shared<Image>(texture), Rect::MakeSize(texture->GetSize()),
      Rect::MakeXYWH(100, 100, 400, 400).Expand(-100, -100), paint);
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [3/450]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModePlusAlphaWideGamut
	)

Definition at line 134 of file aiks_blend_unittests.cc.

                                              {
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.DrawPaint({.color = Color(0.9, 1.0, 0.9, 1.0)});
  canvas.SaveLayer({});
  Paint paint;
  paint.blend_mode = BlendMode::kPlus;
  paint.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 400, 400), paint);
  paint.color = Color::White();
  canvas.DrawImageRect(
      std::make_shared<Image>(texture), Rect::MakeSize(texture->GetSize()),
      Rect::MakeXYWH(100, 100, 400, 400).Expand(-100, -100), paint);
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [4/450]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModeShouldCoverWholeScreen
	)

Definition at line 43 of file aiks_blend_unittests.cc.

                                                  {
  Canvas canvas;
  Paint paint;
 
  paint.color = Color::Red();
  canvas.DrawPaint(paint);
 
  paint.blend_mode = BlendMode::kSourceOver;
  canvas.SaveLayer(paint);
 
  paint.color = Color::White();
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 400, 400), paint);
 
  paint.blend_mode = BlendMode::kSource;
  canvas.SaveLayer(paint);
 
  paint.color = Color::Blue();
  canvas.DrawRect(Rect::MakeXYWH(200, 200, 200, 200), paint);
 
  canvas.Restore();
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [5/450]

impeller::testing::TEST_P	(	AiksTest	,
		BlurHasNoEdge
	)

Definition at line 201 of file aiks_blur_unittests.cc.

                                {
  Scalar sigma = 47.6;
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    if (AiksTest::ImGuiBegin("Controls", nullptr,
                             ImGuiWindowFlags_AlwaysAutoResize)) {
      ImGui::SliderFloat("Sigma", &sigma, 0, 50);
      ImGui::End();
    }
    Canvas canvas;
    canvas.Scale(GetContentScale());
    canvas.DrawPaint({});
    Paint blur = {
        .color = Color::Green(),
        .mask_blur_descriptor =
            Paint::MaskBlurDescriptor{
                .style = FilterContents::BlurStyle::kNormal,
                .sigma = Sigma(sigma),
            },
    };
    canvas.DrawRect(Rect::MakeXYWH(300, 300, 200, 200), blur);
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [6/450]

impeller::testing::TEST_P	(	AiksTest	,
		BlurredRectangleWithShader
	)

Definition at line 227 of file aiks_blur_unittests.cc.

                                             {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  auto paint_lines = [&canvas](Scalar dx, Scalar dy, Paint paint) {
    auto draw_line = [&canvas, &paint](Point a, Point b) {
      canvas.DrawPath(PathBuilder{}.AddLine(a, b).TakePath(), paint);
    };
    paint.stroke_width = 5;
    paint.style = Paint::Style::kStroke;
    draw_line(Point(dx + 100, dy + 100), Point(dx + 200, dy + 200));
    draw_line(Point(dx + 100, dy + 200), Point(dx + 200, dy + 100));
    draw_line(Point(dx + 150, dy + 100), Point(dx + 200, dy + 150));
    draw_line(Point(dx + 100, dy + 150), Point(dx + 150, dy + 200));
  };
 
  AiksContext renderer(GetContext(), nullptr);
  Canvas recorder_canvas;
  for (int x = 0; x < 5; ++x) {
    for (int y = 0; y < 5; ++y) {
      Rect rect = Rect::MakeXYWH(x * 20, y * 20, 20, 20);
      Paint paint{.color =
                      ((x + y) & 1) == 0 ? Color::Yellow() : Color::Blue()};
      recorder_canvas.DrawRect(rect, paint);
    }
  }
  Picture picture = recorder_canvas.EndRecordingAsPicture();
  std::shared_ptr<Texture> texture =
      picture.ToImage(renderer, ISize{100, 100})->GetTexture();
 
  ColorSource image_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {}, {});
  std::shared_ptr<ImageFilter> blur_filter = ImageFilter::MakeBlur(
      Sigma(5), Sigma(5), FilterContents::BlurStyle::kNormal,
      Entity::TileMode::kDecal);
  canvas.DrawRect(Rect::MakeLTRB(0, 0, 300, 600),
                  Paint{.color = Color::DarkGreen()});
  canvas.DrawRect(Rect::MakeLTRB(100, 100, 200, 200),
                  Paint{.color_source = image_source});
  canvas.DrawRect(Rect::MakeLTRB(300, 0, 600, 600),
                  Paint{.color = Color::Red()});
  canvas.DrawRect(
      Rect::MakeLTRB(400, 100, 500, 200),
      Paint{.color_source = image_source, .image_filter = blur_filter});
  paint_lines(0, 300, Paint{.color_source = image_source});
  paint_lines(300, 300,
              Paint{.color_source = image_source, .image_filter = blur_filter});
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [7/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanConvertTriangleFanToTriangles
	)

Definition at line 153 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<SkPoint> vertices = {
    SkPoint::Make(hex_start.x, hex_start.y),
    SkPoint::Make(hex_start.x + center_to_flat, hex_start.y + 0.5 * hexagon_radius),
    SkPoint::Make(hex_start.x + center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    SkPoint::Make(hex_start.x + center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    SkPoint::Make(hex_start.x, hex_start.y + 2 * hexagon_radius),
    SkPoint::Make(hex_start.x, hex_start.y + 2 * hexagon_radius),
    SkPoint::Make(hex_start.x - center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    SkPoint::Make(hex_start.x - center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    SkPoint::Make(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()));
}

◆ TEST_P() [8/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawAnOpenPath
	)

Definition at line 142 of file aiks_path_unittests.cc.

                                    {
  Canvas canvas;
 
  // Starting at (50, 50), draw lines from:
  // 1. (50, height)
  // 2. (width, height)
  // 3. (width, 50)
  PathBuilder builder;
  builder.MoveTo({50, 50});
  builder.LineTo({50, 100});
  builder.LineTo({100, 100});
  builder.LineTo({100, 50});
 
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 10;
 
  canvas.DrawPath(builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [9/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawAnOpenPathThatIsntARect
	)

Definition at line 165 of file aiks_path_unittests.cc.

                                                 {
  Canvas canvas;
 
  // Draw a stroked path that is explicitly closed to verify
  // It doesn't become a rectangle.
  PathBuilder builder;
  builder.MoveTo({50, 50});
  builder.LineTo({520, 120});
  builder.LineTo({300, 310});
  builder.LineTo({100, 50});
  builder.Close();
 
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 10;
 
  canvas.DrawPath(builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [10/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawMultiContourConvexPath
	)

Definition at line 351 of file aiks_path_unittests.cc.

                                                {
  PathBuilder builder = {};
  for (auto i = 0; i < 10; i++) {
    if (i % 2 == 0) {
      builder.AddCircle(Point(100 + 50 * i, 100 + 50 * i), 100);
    } else {
      builder.MoveTo({100.f + 50.f * i - 100, 100.f + 50.f * i});
      builder.LineTo({100.f + 50.f * i, 100.f + 50.f * i - 100});
      builder.LineTo({100.f + 50.f * i - 100, 100.f + 50.f * i - 100});
      builder.Close();
    }
  }
  builder.SetConvexity(Convexity::kConvex);
 
  Canvas canvas;
  canvas.DrawPath(builder.TakePath(), {.color = Color::Red().WithAlpha(0.4)});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [11/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaint
	)

Definition at line 843 of file aiks_unittests.cc.

                               {
  Canvas canvas;
  canvas.Scale(Vector2(0.2, 0.2));
  canvas.DrawPaint({.color = Color::MediumTurquoise()});
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [12/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintMultipleTimes
	)

Definition at line 850 of file aiks_unittests.cc.

                                            {
  Canvas canvas;
  canvas.Scale(Vector2(0.2, 0.2));
  canvas.DrawPaint({.color = Color::MediumTurquoise()});
  canvas.DrawPaint({.color = Color::Color::OrangeRed().WithAlpha(0.5)});
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [13/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintMultipleTimesInteractive
	)

Definition at line 524 of file aiks_blend_unittests.cc.

                                                       {
  auto modes = GetBlendModeSelection();
 
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    static Color background = Color::MediumTurquoise();
    static Color foreground = Color::Color::OrangeRed().WithAlpha(0.5);
    static int current_blend_index = 3;
 
    if (AiksTest::ImGuiBegin("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();
    }
 
    Canvas canvas;
    canvas.Scale(Vector2(0.2, 0.2));
    canvas.DrawPaint({.color = background});
    canvas.DrawPaint(
        {.color = foreground,
         .blend_mode = static_cast<BlendMode>(current_blend_index)});
    return canvas.EndRecordingAsPicture();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [14/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintWithAdvancedBlend
	)

Definition at line 68 of file aiks_blend_unittests.cc.

                                                {
  Canvas canvas;
  canvas.Scale(Vector2(0.2, 0.2));
  canvas.DrawPaint({.color = Color::MediumTurquoise()});
  canvas.DrawPaint({.color = Color::Color::OrangeRed().WithAlpha(0.5),
                    .blend_mode = BlendMode::kHue});
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [15/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPerspectiveTransformWithClips
	)

Definition at line 2667 of file aiks_unittests.cc.

                                                       {
  // Avoiding `GetSecondsElapsed()` to reduce risk of golden flakiness.
  int time = 0;
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    Canvas canvas;
 
    canvas.Save();
    {
      canvas.Translate({300, 300});
 
      // 1. Draw/restore a clip before drawing the image, which will get drawn
      //    to the depth buffer behind the image.
      canvas.Save();
      {
        canvas.DrawPaint({.color = Color::Green()});
        canvas.ClipRect(Rect::MakeLTRB(-180, -180, 180, 180),
                        Entity::ClipOperation::kDifference);
        canvas.DrawPaint({.color = Color::Black()});
      }
      canvas.Restore();  // Restore rectangle difference clip.
 
      canvas.Save();
      {
        // 2. Draw an oval clip that applies to the image, which will get drawn
        //    in front of the image on the depth buffer.
        canvas.ClipOval(Rect::MakeLTRB(-200, -200, 200, 200));
 
        // 3. Draw the rotating image with a perspective transform.
        canvas.Transform(
            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)}}));
        auto image =
            std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
        canvas.DrawImage(image, -Point(image->GetSize()) / 2, {});
      }
      canvas.Restore();  // Restore oval intersect clip.
 
      // 4. Draw a semi-translucent blue circle atop all previous draws.
      canvas.DrawCircle({}, 230, {.color = Color::Blue().WithAlpha(0.4)});
    }
    canvas.Restore();  // Restore translation.
 
    return canvas.EndRecordingAsPicture();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [16/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPoints
	)

Definition at line 2205 of file aiks_unittests.cc.

                                {
  std::vector<Point> points = {
      {0, 0},      //
      {100, 100},  //
      {100, 0},    //
      {0, 100},    //
      {0, 0},      //
      {48, 48},    //
      {52, 52},    //
  };
  std::vector<PointStyle> caps = {
      PointStyle::kRound,
      PointStyle::kSquare,
  };
  Paint paint;
  paint.color = Color::Yellow().WithAlpha(0.5);
 
  Paint background;
  background.color = Color::Black();
 
  Canvas canvas;
  canvas.DrawPaint(background);
  canvas.Translate({200, 200});
  canvas.DrawPoints(points, 10, paint, PointStyle::kRound);
  canvas.Translate({150, 0});
  canvas.DrawPoints(points, 10, paint, PointStyle::kSquare);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [17/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPointsWithTextureMap
	)

Definition at line 2235 of file aiks_unittests.cc.

                                              {
  auto texture = CreateTextureForFixture("table_mountain_nx.png",
                                         /*enable_mipmapping=*/true);
 
  std::vector<Point> points = {
      {0, 0},      //
      {100, 100},  //
      {100, 0},    //
      {0, 100},    //
      {0, 0},      //
      {48, 48},    //
      {52, 52},    //
  };
  std::vector<PointStyle> caps = {
      PointStyle::kRound,
      PointStyle::kSquare,
  };
  Paint paint;
  paint.color_source = ColorSource::MakeImage(texture, Entity::TileMode::kClamp,
                                              Entity::TileMode::kClamp, {}, {});
 
  Canvas canvas;
  canvas.Translate({200, 200});
  canvas.DrawPoints(points, 100, paint, PointStyle::kRound);
  canvas.Translate({150, 0});
  canvas.DrawPoints(points, 100, paint, PointStyle::kSquare);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [18/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanEmptyPictureConvertToImage
	)

Definition at line 385 of file aiks_unittests.cc.

                                                {
  Canvas recorder_canvas;
 
  Canvas canvas;
  AiksContext renderer(GetContext(), nullptr);
  Paint paint;
  paint.color = Color::BlackTransparent();
  canvas.DrawPaint(paint);
  Picture picture = recorder_canvas.EndRecordingAsPicture();
  auto image = picture.ToImage(renderer, ISize{1000, 1000});
  if (image) {
    canvas.DrawImage(image, Point(), Paint());
    paint.color = Color{0.1, 0.1, 0.1, 0.2};
    canvas.DrawRect(Rect::MakeSize(ISize{1000, 1000}), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [19/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformFullScreenMSAA
	)

Definition at line 445 of file aiks_unittests.cc.

                                           {
  Canvas canvas;
 
  Paint red;
  red.color = Color::Red();
 
  canvas.DrawCircle({250, 250}, 125, red);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [20/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSaveLayerWithBounds
	)

Definition at line 468 of file aiks_unittests.cc.

                                                {
  Canvas canvas;
 
  Paint red;
  red.color = Color::Red();
 
  Paint green;
  green.color = Color::Green();
 
  Paint blue;
  blue.color = Color::Blue();
 
  Paint save;
  save.color = Color::Black();
 
  canvas.SaveLayer(save, Rect::MakeXYWH(0, 0, 50, 50));
 
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 100, 100), red);
  canvas.DrawRect(Rect::MakeXYWH(10, 10, 100, 100), green);
  canvas.DrawRect(Rect::MakeXYWH(20, 20, 100, 100), blue);
 
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [21/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated
	)

Definition at line 494 of file aiks_unittests.cc.

                                                                         {
  Canvas canvas;
 
  Paint red;
  red.color = Color::Red();
 
  Paint green;
  green.color = Color::Green();
 
  Paint blue;
  blue.color = Color::Blue();
 
  Paint save;
  save.color = Color::Black().WithAlpha(0.5);
 
  canvas.SaveLayer(save, Rect::MakeXYWH(0, 0, 100000, 100000));
 
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 100, 100), red);
  canvas.DrawRect(Rect::MakeXYWH(10, 10, 100, 100), green);
  canvas.DrawRect(Rect::MakeXYWH(20, 20, 100, 100), blue);
 
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [22/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSkew
	)

Definition at line 456 of file aiks_unittests.cc.

                                 {
  Canvas canvas;
 
  Paint red;
  red.color = Color::Red();
 
  canvas.Skew(2, 5);
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 100, 100), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [23/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanPictureConvertToImage
	)

Definition at line 359 of file aiks_unittests.cc.

                                           {
  Canvas recorder_canvas;
  Paint paint;
  paint.color = Color{0.9568, 0.2627, 0.2118, 1.0};
  recorder_canvas.DrawRect(Rect::MakeXYWH(100.0, 100.0, 600, 600), paint);
  paint.color = Color{0.1294, 0.5882, 0.9529, 1.0};
  recorder_canvas.DrawRect(Rect::MakeXYWH(200.0, 200.0, 600, 600), paint);
 
  Canvas canvas;
  AiksContext renderer(GetContext(), nullptr);
  paint.color = Color::BlackTransparent();
  canvas.DrawPaint(paint);
  Picture picture = recorder_canvas.EndRecordingAsPicture();
  auto image = picture.ToImage(renderer, ISize{1000, 1000});
  if (image) {
    canvas.DrawImage(image, Point(), Paint());
    paint.color = Color{0.1, 0.1, 0.1, 0.2};
    canvas.DrawRect(Rect::MakeSize(ISize{1000, 1000}), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [24/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderAdvancedBlendColorFilterWithSaveLayer
	)

Definition at line 21 of file aiks_blend_unittests.cc.

                                                                 {
  Canvas canvas;
 
  Rect layer_rect = Rect::MakeXYWH(0, 0, 500, 500);
  canvas.ClipRect(layer_rect);
 
  canvas.SaveLayer(
      {
          .color_filter = ColorFilter::MakeBlend(BlendMode::kDifference,
                                                 Color(0, 1, 0, 0.5)),
      },
      layer_rect);
 
  Paint paint;
  canvas.DrawPaint({.color = Color::Black()});
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300),
                  {.color = Color::White()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [25/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlur
	)

Definition at line 102 of file aiks_blur_unittests.cc.

                                        {
  Canvas canvas;
  canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
  canvas.DrawCircle({300, 200}, 100, {.color = Color::GreenYellow()});
  canvas.DrawCircle({140, 170}, 75, {.color = Color::DarkMagenta()});
  canvas.DrawCircle({180, 120}, 100, {.color = Color::OrangeRed()});
  canvas.ClipRRect(Rect::MakeLTRB(75, 50, 375, 275), {20, 20});
  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(30.0), Sigma(30.0),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [26/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurHugeSigma
	)

Definition at line 118 of file aiks_blur_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.DrawCircle({400, 400}, 300, {.color = Color::Green()});
  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(999999), Sigma(999999),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [27/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurInteractive
	)

Definition at line 78 of file aiks_blur_unittests.cc.

                                                   {
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    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);
 
    Canvas canvas;
    canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
    canvas.DrawCircle({300, 200}, 100, {.color = Color::GreenYellow()});
    canvas.DrawCircle({140, 170}, 75, {.color = Color::DarkMagenta()});
    canvas.DrawCircle({180, 120}, 100, {.color = Color::OrangeRed()});
    canvas.ClipRRect(Rect::MakeLTRB(a.x, a.y, b.x, b.y), {20, 20});
    canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                     ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                           FilterContents::BlurStyle::kNormal,
                                           Entity::TileMode::kClamp));
    canvas.Restore();
 
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [28/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedBackdropFilter
	)

Definition at line 2717 of file aiks_unittests.cc.

                                                 {
  Canvas canvas;
  Paint paint;
 
  canvas.Scale(GetContentScale());
 
  // Draw something interesting in the background.
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.1294, 0.5882, 0.9529, 1.0}};
  std::vector<Scalar> stops = {
      0.0,
      1.0,
  };
  paint.color_source = ColorSource::MakeLinearGradient(
      {0, 0}, {100, 100}, std::move(colors), std::move(stops),
      Entity::TileMode::kRepeat, {});
  canvas.DrawPaint(paint);
 
  Rect clip_rect = Rect::MakeLTRB(50, 50, 400, 300);
 
  // Draw a clipped SaveLayer, where the clip coverage and SaveLayer size are
  // the same.
  canvas.ClipRRect(clip_rect, Size(100, 100),
                   Entity::ClipOperation::kIntersect);
  canvas.SaveLayer({}, clip_rect,
                   ImageFilter::MakeFromColorFilter(*ColorFilter::MakeBlend(
                       BlendMode::kExclusion, Color::Red())));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [29/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedBlur
	)

Definition at line 130 of file aiks_blur_unittests.cc.

                                       {
  Canvas canvas;
  canvas.ClipRect(Rect::MakeXYWH(100, 150, 400, 400));
  canvas.DrawCircle(
      {400, 400}, 200,
      {
          .color = Color::Green(),
          .image_filter = ImageFilter::MakeBlur(
              Sigma(20.0), Sigma(20.0), FilterContents::BlurStyle::kNormal,
              Entity::TileMode::kDecal),
      });
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [30/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedLayers
	)

Definition at line 1431 of file aiks_unittests.cc.

                                         {
  Canvas canvas;
 
  canvas.DrawPaint({.color = Color::White()});
 
  // Draw a green circle on the screen.
  {
    // Increase the clip depth for the savelayer to contend with.
    canvas.ClipPath(PathBuilder{}.AddCircle({100, 100}, 50).TakePath());
 
    canvas.SaveLayer({}, Rect::MakeXYWH(50, 50, 100, 100));
 
    // Fill the layer with white.
    canvas.DrawRect(Rect::MakeSize(Size{400, 400}), {.color = Color::White()});
    // Fill the layer with green, but do so with a color blend that can't be
    // collapsed into the parent pass.
    // TODO(jonahwilliams): this blend mode was changed from color burn to
    // hardlight to work around https://github.com/flutter/flutter/issues/136554
    // .
    canvas.DrawRect(
        Rect::MakeSize(Size{400, 400}),
        {.color = Color::Green(), .blend_mode = BlendMode::kHardLight});
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [31/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedRuntimeEffects
	)

Definition at line 2143 of file aiks_unittests.cc.

                                                 {
  auto runtime_stages =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
 
  auto runtime_stage =
      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  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));
 
  std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
 
  Paint paint;
  paint.color_source = ColorSource::MakeRuntimeEffect(
      runtime_stage, uniform_data, texture_inputs);
 
  Canvas canvas;
  canvas.Save();
  canvas.ClipRRect(Rect::MakeXYWH(0, 0, 400, 400), {10.0, 10.0},
                   Entity::ClipOperation::kIntersect);
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 400, 400), paint);
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [32/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClips
	)

Definition at line 397 of file aiks_path_unittests.cc.

                                 {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Fuchsia();
  canvas.ClipPath(
      PathBuilder{}.AddRect(Rect::MakeXYWH(0, 0, 500, 500)).TakePath());
  canvas.DrawPath(PathBuilder{}.AddCircle({500, 500}, 250).TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [33/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColoredRect
	)

Definition at line 73 of file aiks_unittests.cc.

                                       {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Blue();
  canvas.DrawPath(PathBuilder{}
                      .AddRect(Rect::MakeXYWH(100.0, 100.0, 100.0, 100.0))
                      .TakePath(),
                  paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [34/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColorFilterWithInvertColors
	)

Definition at line 106 of file aiks_unittests.cc.

                                                       {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.color_filter =
      ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Yellow());
  paint.invert_colors = true;
 
  canvas.DrawRect(Rect::MakeLTRB(0, 0, 100, 100), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [35/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColorFilterWithInvertColorsDrawPaint
	)

Definition at line 118 of file aiks_unittests.cc.

                                                                {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.color_filter =
      ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Yellow());
  paint.invert_colors = true;
 
  canvas.DrawPaint(paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [36/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradient
	)

Definition at line 550 of file aiks_dl_gradient_unittests.cc.

                                           {
  Scalar size = 256;
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(SkRect::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<SkPoint, float, SkPoint, float>, 8> array{
      std::make_tuple(SkPoint::Make(size / 2.f, size / 2.f), 0.f,
                      SkPoint::Make(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(SkPoint::Make(size / 2.f, size / 2.f), size / 4.f,
                      SkPoint::Make(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(SkPoint::Make(size / 4.f, size / 4.f), 0.f,
                      SkPoint::Make(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(SkPoint::Make(size / 4.f, size / 4.f), size / 2.f,
                      SkPoint::Make(size / 2.f, size / 2.f), 0),
      std::make_tuple(SkPoint::Make(size / 4.f, size / 4.f), size / 4.f,
                      SkPoint::Make(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(SkPoint::Make(size / 4.f, size / 4.f), size / 16.f,
                      SkPoint::Make(size / 2.f, size / 2.f), size / 8.f),
      std::make_tuple(SkPoint::Make(size / 4.f, size / 4.f), size / 8.f,
                      SkPoint::Make(size / 2.f, size / 2.f), size / 16.f),
      std::make_tuple(SkPoint::Make(size / 8.f, size / 8.f), size / 8.f,
                      SkPoint::Make(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(
        std::get<2>(array[i]), std::get<3>(array[i]), std::get<0>(array[i]),
        std::get<1>(array[i]), stops.size(), colors.data(), stops.data(),
        DlTileMode::kClamp));
    builder.DrawRect(SkRect::MakeXYWH(0, 0, size, size), paint);
    builder.Restore();
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [37/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradientWithDitheringEnabled
	)

Definition at line 186 of file aiks_dl_gradient_unittests.cc.

                                                               {
  CanRenderConicalGradientWithDithering(this);
}

◆ TEST_P() [38/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderCurvedStrokes
	)

Definition at line 31 of file aiks_path_unittests.cc.

                                         {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.stroke_width = 25.0;
  paint.style = Paint::Style::kStroke;
  canvas.DrawPath(PathBuilder{}.AddCircle({500, 500}, 250).TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [39/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDestructiveSaveLayer
	)

Definition at line 2128 of file aiks_unittests.cc.

                                                {
  Canvas canvas;
 
  canvas.DrawPaint({.color = Color::Red()});
  // 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.
  canvas.SaveLayer({.blend_mode = BlendMode::kSource});
  canvas.DrawCircle({300, 300}, 100, {.color = Color::Green()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [40/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferenceClips
	)

Definition at line 42 of file aiks_dl_clip_unittests.cc.

                                           {
  DisplayListBuilder builder;
  builder.Translate(400, 400);
 
  // Limit drawing to face circle with a clip.
  builder.ClipPath(CreateCircle(0, 0, 200));
  builder.Save();
 
  // Cut away eyes/mouth using difference clips.
  builder.ClipPath(CreateCircle(-100, -50, 30), DlCanvas::ClipOp::kDifference);
  builder.ClipPath(CreateCircle(100, -50, 30), DlCanvas::ClipOp::kDifference);
 
  SkPath path;
  path.moveTo(-100, 50);
  path.quadTo(0, 150, 100, 50);
  builder.ClipPath(path, DlCanvas::ClipOp::kDifference);
 
  // Draw a huge yellow rectangle to prove the clipping works.
  DlPaint paint;
  paint.setColor(DlColor::kYellow());
  builder.DrawRect(SkRect::MakeXYWH(-1000, -1000, 2000, 2000), paint);
 
  // Remove the difference clips and draw hair that partially covers the eyes.
  builder.Restore();
  paint.setColor(DlColor::kMaroon());
  SkPath path_2;
  path_2.moveTo(200, -200);
  path_2.lineTo(-200, -200);
  path_2.lineTo(-200, -40);
  path_2.cubicTo({0, -40}, {0, -80}, {200, -80});
 
  builder.DrawPath(path_2, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [41/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferencePaths
	)

Definition at line 113 of file aiks_path_unittests.cc.

                                           {
  Canvas canvas;
 
  Paint paint;
  paint.color = Color::Red();
 
  PathBuilder builder;
 
  PathBuilder::RoundingRadii radii;
  radii.top_left = {50, 25};
  radii.top_right = {25, 50};
  radii.bottom_right = {50, 25};
  radii.bottom_left = {25, 50};
 
  builder.AddRoundedRect(Rect::MakeXYWH(100, 100, 200, 200), radii);
  builder.AddCircle({200, 200}, 50);
  auto path = builder.TakePath(FillType::kOdd);
 
  canvas.DrawImage(
      std::make_shared<Image>(CreateTextureForFixture("boston.jpg")), {10, 10},
      Paint{});
  canvas.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [42/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferentShapesWithSameColorSource
	)

Definition at line 332 of file aiks_unittests.cc.

                                                              {
  Canvas canvas;
  Paint paint;
 
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.1294, 0.5882, 0.9529, 1.0}};
  std::vector<Scalar> stops = {
      0.0,
      1.0,
  };
 
  paint.color_source = ColorSource::MakeLinearGradient(
      {0, 0}, {100, 100}, std::move(colors), std::move(stops),
      Entity::TileMode::kRepeat, {});
 
  canvas.Save();
  canvas.Translate({100, 100, 0});
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), paint);
  canvas.Restore();
 
  canvas.Save();
  canvas.Translate({100, 400, 0});
  canvas.DrawCircle({100, 100}, 100, paint);
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [43/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrame
	)

Definition at line 735 of file aiks_unittests.cc.

                                          {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [44/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrameWithAlpha
	)

Definition at line 757 of file aiks_unittests.cc.

                                                   {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
      {.color = Color::Black().WithAlpha(0.5)}));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [45/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrameWithBlur
	)

Definition at line 744 of file aiks_unittests.cc.

                                                  {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
      TextRenderOptions{.color = Color::Blue(),
                        .mask_blur_descriptor = Paint::MaskBlurDescriptor{
                            .style = FilterContents::BlurStyle::kNormal,
                            .sigma = Sigma(4)}}));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [46/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderForegroundAdvancedBlendWithMaskBlur
	)

Definition at line 57 of file aiks_blur_unittests.cc.

                                                               {
  // This case triggers the ForegroundAdvancedBlend path. The color filter
  // should apply to the color only, and respect the alpha mask.
  Canvas canvas;
  canvas.ClipRect(Rect::MakeXYWH(100, 150, 400, 400));
  canvas.DrawCircle({400, 400}, 200,
                    {
                        .color = Color::Grey(),
                        .color_filter = ColorFilter::MakeBlend(
                            BlendMode::kColor, Color::Green()),
                        .mask_blur_descriptor =
                            Paint::MaskBlurDescriptor{
                                .style = FilterContents::BlurStyle::kNormal,
                                .sigma = Radius(20),
                            },
                    });
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [47/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderForegroundBlendWithMaskBlur
	)

Definition at line 36 of file aiks_blur_unittests.cc.

                                                       {
  // This case triggers the ForegroundPorterDuffBlend path. The color filter
  // should apply to the color only, and respect the alpha mask.
  Canvas canvas;
  canvas.ClipRect(Rect::MakeXYWH(100, 150, 400, 400));
  canvas.DrawCircle({400, 400}, 200,
                    {
                        .color = Color::White(),
                        .color_filter = ColorFilter::MakeBlend(
                            BlendMode::kSource, Color::Green()),
                        .mask_blur_descriptor =
                            Paint::MaskBlurDescriptor{
                                .style = FilterContents::BlurStyle::kNormal,
                                .sigma = Radius(20),
                            },
                    });
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [48/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGradientDecalWithBackground
	)

Definition at line 593 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(SkRect::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(SkRect::MakeLTRB(0, 0, 200, 200), paint);
    builder.Restore();
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [49/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGroupOpacity
	)

Definition at line 35 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(nullptr, &alpha);
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 100, 100), red);
  builder.DrawRect(SkRect::MakeXYWH(200, 200, 100, 100), green);
  builder.DrawRect(SkRect::MakeXYWH(400, 400, 100, 100), blue);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [50/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGroupOpacityToSavelayer
	)

Definition at line 57 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.
  SkRect bounds = SkRect::MakeLTRB(0, 0, 500, 500);
  builder.SaveLayer(&bounds, &alpha);
  builder.SaveLayer(&bounds, &alpha);
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 400, 400), red);
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 450, 450), red);
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [51/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderImage
	)

Definition at line 84 of file aiks_unittests.cc.

                                 {
  Canvas canvas;
  Paint paint;
  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
  paint.color = Color::Red();
  canvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [52/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderImageRect
	)

Definition at line 219 of file aiks_unittests.cc.

                                     {
  Canvas canvas;
  Paint paint;
  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
  Size image_half_size = Size(image->GetSize()) * 0.5;
 
  // Render the bottom right quarter of the source image in a stretched rect.
  auto source_rect = Rect::MakeSize(image_half_size);
  source_rect = source_rect.Shift(Point(image_half_size));
 
  canvas.DrawImageRect(image, source_rect, Rect::MakeXYWH(100, 100, 600, 600),
                       paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [53/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderInvertedImageWithColorFilter
	)

Definition at line 93 of file aiks_unittests.cc.

                                                        {
  Canvas canvas;
  Paint paint;
  auto image = std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
  paint.color = Color::Red();
  paint.color_filter =
      ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Yellow());
  paint.invert_colors = true;
 
  canvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [54/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderItalicizedText
	)

Definition at line 718 of file aiks_unittests.cc.

                                          {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "HomemadeApple.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [55/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientClamp
	)

Definition at line 67 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderLinearGradient(this, DlTileMode::kClamp);
}

◆ TEST_P() [56/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientDecal
	)

Definition at line 76 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderLinearGradient(this, DlTileMode::kDecal);
}

◆ TEST_P() [57/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientDecalWithColorFilter
	)

Definition at line 80 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(DlBlendColorFilter::Make(DlColor::kGreen().withAlpha(64),
                                                DlBlendMode::kSrcOver));
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [58/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsClamp
	)

Definition at line 256 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderLinearGradientManyColors(this, DlTileMode::kClamp);
}

◆ TEST_P() [59/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsDecal
	)

Definition at line 265 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderLinearGradientManyColors(this, DlTileMode::kDecal);
}

◆ TEST_P() [60/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsMirror
	)

Definition at line 262 of file aiks_dl_gradient_unittests.cc.

                                                          {
  CanRenderLinearGradientManyColors(this, DlTileMode::kMirror);
}

◆ TEST_P() [61/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsRepeat
	)

Definition at line 259 of file aiks_dl_gradient_unittests.cc.

                                                          {
  CanRenderLinearGradientManyColors(this, DlTileMode::kRepeat);
}

◆ TEST_P() [62/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsUnevenStops
	)

Definition at line 300 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 (AiksTest::ImGuiBegin("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(SkRect::MakeXYWH(0, 0, 600, 600), paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [63/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientMaskBlur
	)

Definition at line 348 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({300, 300}, 200, paint);
  builder.DrawRect(SkRect::MakeLTRB(100, 300, 500, 600), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [64/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientMirror
	)

Definition at line 73 of file aiks_dl_gradient_unittests.cc.

                                                {
  CanRenderLinearGradient(this, DlTileMode::kMirror);
}

◆ TEST_P() [65/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientRepeat
	)

Definition at line 70 of file aiks_dl_gradient_unittests.cc.

                                                {
  CanRenderLinearGradient(this, DlTileMode::kRepeat);
}

◆ TEST_P() [66/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWayManyColorsClamp
	)

Definition at line 296 of file aiks_dl_gradient_unittests.cc.

                                                            {
  CanRenderLinearGradientWayManyColors(this, DlTileMode::kClamp);
}

◆ TEST_P() [67/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithDitheringEnabled
	)

Definition at line 120 of file aiks_dl_gradient_unittests.cc.

                                                              {
  CanRenderLinearGradientWithDithering(this);
}

◆ TEST_P() [68/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithOverlappingStopsClamp
	)

Definition at line 215 of file aiks_dl_gradient_unittests.cc.

                                                                   {
  CanRenderLinearGradientWithOverlappingStops(this, DlTileMode::kClamp);
}

◆ TEST_P() [69/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMaskBlurHugeSigma
	)

Definition at line 23 of file aiks_blur_unittests.cc.

                                             {
  Canvas canvas;
  canvas.DrawCircle({400, 400}, 300,
                    {.color = Color::Green(),
                     .mask_blur_descriptor = Paint::MaskBlurDescriptor{
                         .style = FilterContents::BlurStyle::kNormal,
                         .sigma = Sigma(99999),
                     }});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [70/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderNestedClips
	)

Definition at line 27 of file aiks_dl_clip_unittests.cc.

                                       {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kFuchsia());
 
  builder.Save();
  builder.ClipPath(CreateCircle(200, 400, 300));
  builder.Restore();
  builder.ClipPath(CreateCircle(600, 400, 300));
  builder.ClipPath(CreateCircle(400, 600, 300));
  builder.DrawRect(SkRect::MakeXYWH(200, 200, 400, 400), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [71/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderOverlappingMultiContourPath
	)

Definition at line 407 of file aiks_path_unittests.cc.

                                                       {
  Canvas canvas;
 
  Paint paint;
  paint.color = Color::Red();
 
  PathBuilder::RoundingRadii radii;
  radii.top_left = {50, 50};
  radii.top_right = {50, 50};
  radii.bottom_right = {50, 50};
  radii.bottom_left = {50, 50};
 
  const Scalar kTriangleHeight = 100;
  canvas.Translate(Vector2(200, 200));
  // Form a path similar to the Material drop slider value indicator. Both
  // shapes should render identically side-by-side.
  {
    auto path =
        PathBuilder{}
            .MoveTo({0, kTriangleHeight})
            .LineTo({-kTriangleHeight / 2.0f, 0})
            .LineTo({kTriangleHeight / 2.0f, 0})
            .Close()
            .AddRoundedRect(
                Rect::MakeXYWH(-kTriangleHeight / 2.0f, -kTriangleHeight / 2.0f,
                               kTriangleHeight, kTriangleHeight),
                radii)
            .TakePath();
 
    canvas.DrawPath(path, paint);
  }
  canvas.Translate(Vector2(100, 0));
  {
    auto path =
        PathBuilder{}
            .MoveTo({0, kTriangleHeight})
            .LineTo({-kTriangleHeight / 2.0f, 0})
            .LineTo({0, -10})
            .LineTo({kTriangleHeight / 2.0f, 0})
            .Close()
            .AddRoundedRect(
                Rect::MakeXYWH(-kTriangleHeight / 2.0f, -kTriangleHeight / 2.0f,
                               kTriangleHeight, kTriangleHeight),
                radii)
            .TakePath();
 
    canvas.DrawPath(path, paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [72/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderQuadraticStrokeWithInstantTurn
	)

Definition at line 94 of file aiks_path_unittests.cc.

                                                          {
  Canvas canvas;
 
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_cap = Cap::kRound;
  paint.stroke_width = 50;
 
  // Should draw a diagonal pill shape. If flat on either end, the stroke is
  // rendering wrong.
  PathBuilder builder;
  builder.MoveTo({250, 250});
  builder.QuadraticCurveTo({100, 100}, {250, 250});
 
  canvas.DrawPath(builder.TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [73/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradient
	)

Definition at line 371 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 (AiksTest::ImGuiBegin("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(SkRect::MakeXYWH(0, 0, 600, 600), paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [74/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientManyColors
	)

Definition at line 411 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 (AiksTest::ImGuiBegin("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(SkRect::MakeXYWH(0, 0, 600, 600), paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [75/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientWithDitheringEnabled
	)

Definition at line 140 of file aiks_dl_gradient_unittests.cc.

                                                              {
  CanRenderRadialGradientWithDithering(this);
}

◆ TEST_P() [76/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRoundedRectWithNonUniformRadii
	)

Definition at line 521 of file aiks_unittests.cc.

                                                          {
  Canvas canvas;
 
  Paint paint;
  paint.color = Color::Red();
 
  PathBuilder::RoundingRadii radii;
  radii.top_left = {50, 25};
  radii.top_right = {25, 50};
  radii.bottom_right = {50, 25};
  radii.bottom_left = {25, 50};
 
  auto path = PathBuilder{}
                  .AddRoundedRect(Rect::MakeXYWH(100, 100, 500, 500), radii)
                  .TakePath();
 
  canvas.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [77/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSimpleClips
	)

Definition at line 234 of file aiks_unittests.cc.

                                       {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
 
  paint.color = Color::White();
  canvas.DrawPaint(paint);
 
  auto draw = [&canvas](const Paint& paint, Scalar x, Scalar y) {
    canvas.Save();
    canvas.Translate({x, y});
    {
      canvas.Save();
      canvas.ClipRect(Rect::MakeLTRB(50, 50, 150, 150));
      canvas.DrawPaint(paint);
      canvas.Restore();
    }
    {
      canvas.Save();
      canvas.ClipOval(Rect::MakeLTRB(200, 50, 300, 150));
      canvas.DrawPaint(paint);
      canvas.Restore();
    }
    {
      canvas.Save();
      canvas.ClipRRect(Rect::MakeLTRB(50, 200, 150, 300), {20, 20});
      canvas.DrawPaint(paint);
      canvas.Restore();
    }
    {
      canvas.Save();
      canvas.ClipRRect(Rect::MakeLTRB(200, 230, 300, 270), {20, 20});
      canvas.DrawPaint(paint);
      canvas.Restore();
    }
    {
      canvas.Save();
      canvas.ClipRRect(Rect::MakeLTRB(230, 200, 270, 300), {20, 20});
      canvas.DrawPaint(paint);
      canvas.Restore();
    }
    canvas.Restore();
  };
 
  paint.color = Color::Blue();
  draw(paint, 0, 0);
 
  std::vector<Color> gradient_colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  paint.color_source = ColorSource::MakeRadialGradient(
      {500, 600}, 75, std::move(gradient_colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  draw(paint, 0, 300);
 
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({0, 0}));
  draw(paint, 300, 0);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [78/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokedTextFrame
	)

Definition at line 629 of file aiks_unittests.cc.

                                            {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf",
      {
          .stroke = true,
      }));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [79/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokePathThatEndsAtSharpTurn
	)

Definition at line 63 of file aiks_path_unittests.cc.

                                                         {
  Canvas canvas;
 
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 200;
 
  Rect rect = Rect::MakeXYWH(100, 100, 200, 200);
  PathBuilder builder;
  builder.AddArc(rect, Degrees(0), Degrees(90), false);
 
  canvas.DrawPath(builder.TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [80/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokePathWithCubicLine
	)

Definition at line 79 of file aiks_path_unittests.cc.

                                                   {
  Canvas canvas;
 
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 20;
 
  PathBuilder builder;
  builder.AddCubicCurve({0, 200}, {50, 400}, {350, 0}, {400, 200});
 
  canvas.DrawPath(builder.TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [81/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokes
	)

Definition at line 20 of file aiks_path_unittests.cc.

                                   {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.stroke_width = 20.0;
  paint.style = Paint::Style::kStroke;
  canvas.DrawPath(PathBuilder{}.AddLine({200, 100}, {800, 100}).TakePath(),
                  paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [82/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientClamp
	)

Definition at line 490 of file aiks_dl_gradient_unittests.cc.

                                              {
  CanRenderSweepGradient(this, DlTileMode::kClamp);
}

◆ TEST_P() [83/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientDecal
	)

Definition at line 499 of file aiks_dl_gradient_unittests.cc.

                                              {
  CanRenderSweepGradient(this, DlTileMode::kDecal);
}

◆ TEST_P() [84/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsClamp
	)

Definition at line 537 of file aiks_dl_gradient_unittests.cc.

                                                        {
  CanRenderSweepGradientManyColors(this, DlTileMode::kClamp);
}

◆ TEST_P() [85/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsDecal
	)

Definition at line 546 of file aiks_dl_gradient_unittests.cc.

                                                        {
  CanRenderSweepGradientManyColors(this, DlTileMode::kDecal);
}

◆ TEST_P() [86/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsMirror
	)

Definition at line 543 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderSweepGradientManyColors(this, DlTileMode::kMirror);
}

◆ TEST_P() [87/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsRepeat
	)

Definition at line 540 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderSweepGradientManyColors(this, DlTileMode::kRepeat);
}

◆ TEST_P() [88/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientMirror
	)

Definition at line 496 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderSweepGradient(this, DlTileMode::kMirror);
}

◆ TEST_P() [89/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientRepeat
	)

Definition at line 493 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderSweepGradient(this, DlTileMode::kRepeat);
}

◆ TEST_P() [90/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientWithDitheringEnabled
	)

Definition at line 163 of file aiks_dl_gradient_unittests.cc.

                                                             {
  CanRenderSweepGradientWithDithering(this);
}

◆ TEST_P() [91/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrame
	)

Definition at line 620 of file aiks_unittests.cc.

                                     {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [92/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameSTB
	)

Definition at line 661 of file aiks_unittests.cc.

                                        {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
  ASSERT_TRUE(RenderTextInCanvasSTB(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  SetTypographerContext(TypographerContextSTB::Make());
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [93/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithFractionScaling
	)

Definition at line 651 of file aiks_unittests.cc.

                                                        {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
  canvas.Scale({2.625, 2.625, 1});
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [94/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithHalfScaling
	)

Definition at line 641 of file aiks_unittests.cc.

                                                    {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
  canvas.Scale({0.5, 0.5, 1});
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [95/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextInSaveLayer
	)

Definition at line 767 of file aiks_unittests.cc.

                                           {
  Canvas canvas;
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  canvas.Translate({100, 100});
  canvas.Scale(Vector2{0.5, 0.5});
 
  // Blend the layer with the parent pass using kClear to expose the coverage.
  canvas.SaveLayer({.blend_mode = BlendMode::kClear});
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
  canvas.Restore();
 
  // Render the text again over the cleared coverage rect.
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [96/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextOutsideBoundaries
	)

Definition at line 789 of file aiks_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.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);
 
  Paint text_paint;
  text_paint.color = Color::Blue().WithAlpha(0.8);
 
  struct {
    Point position;
    const char* text;
  } text[] = {{Point(0, 0), "0F0F0F0"},
              {Point(1, 2), "789"},
              {Point(1, 3), "456"},
              {Point(1, 4), "123"},
              {Point(0, 6), "0F0F0F0"}};
  for (auto& t : text) {
    canvas.Save();
    canvas.Translate(t.position * Point(font_size * 2, font_size * 1.1));
    {
      auto blob = SkTextBlob::MakeFromString(t.text, sk_font);
      ASSERT_NE(blob, nullptr);
      auto frame = MakeTextFrameFromTextBlobSkia(blob);
      canvas.DrawTextFrame(frame, Point(), text_paint);
    }
    canvas.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [97/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextWithLargePerspectiveTransform
	)

Definition at line 2822 of file aiks_unittests.cc.

                                                             {
  // Verifies that text scales are clamped to work around
  // https://github.com/flutter/flutter/issues/136112 .
 
  Canvas canvas;
  Paint save_paint;
  canvas.SaveLayer(save_paint);
  canvas.Transform(Matrix(2000, 0, 0, 0,   //
                          0, 2000, 0, 0,   //
                          0, 0, -1, 9000,  //
                          0, 0, -1, 7000   //
                          ));
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), canvas, "Hello world",
                                     "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [98/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThickCurvedStrokes
	)

Definition at line 41 of file aiks_path_unittests.cc.

                                              {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.stroke_width = 100.0;
  paint.style = Paint::Style::kStroke;
  canvas.DrawPath(PathBuilder{}.AddCircle({100, 100}, 50).TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [99/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThinCurvedStrokes
	)

Definition at line 51 of file aiks_path_unittests.cc.

                                             {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  // Impeller doesn't support hairlines yet, but size this guarantees
  // the smallest possible stroke width.
  paint.stroke_width = 0.01;
  paint.style = Paint::Style::kStroke;
  canvas.DrawPath(PathBuilder{}.AddCircle({100, 100}, 50).TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [100/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureClamp
	)

Definition at line 198 of file aiks_unittests.cc.

                                             {
  CanRenderTiledTexture(this, Entity::TileMode::kClamp);
}

◆ TEST_P() [101/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureClampWithTranslate
	)

Definition at line 214 of file aiks_unittests.cc.

                                                          {
  CanRenderTiledTexture(this, Entity::TileMode::kClamp,
                        Matrix::MakeTranslation({172.f, 172.f, 0.f}));
}

◆ TEST_P() [102/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureDecal
	)

Definition at line 210 of file aiks_unittests.cc.

                                             {
  CanRenderTiledTexture(this, Entity::TileMode::kDecal);
}

◆ TEST_P() [103/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureMirror
	)

Definition at line 206 of file aiks_unittests.cc.

                                              {
  CanRenderTiledTexture(this, Entity::TileMode::kMirror);
}

◆ TEST_P() [104/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureRepeat
	)

Definition at line 202 of file aiks_unittests.cc.

                                              {
  CanRenderTiledTexture(this, Entity::TileMode::kRepeat);
}

◆ TEST_P() [105/450]

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 2082 of file aiks_unittests.cc.

                                                    {
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Red()});
 
  // Draw two overlapping subpixel circles.
  canvas.SaveLayer({});
  canvas.DrawCircle({100, 100}, 0.1, {.color = Color::Yellow()});
  canvas.Restore();
  canvas.SaveLayer({});
  canvas.DrawCircle({100, 100}, 0.1, {.color = Color::Yellow()});
  canvas.Restore();
 
  canvas.DrawPaint({.color = Color::Green()});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [106/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderWithContiguousClipRestores
	)

Definition at line 78 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(SkRect::MakeXYWH(100, 100, 100, 100));
  builder.ClipRect(SkRect::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()));
}

◆ TEST_P() [107/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanSaveLayerStandalone
	)

Definition at line 314 of file aiks_unittests.cc.

                                         {
  Canvas canvas;
 
  Paint red;
  red.color = Color::Red();
 
  Paint alpha;
  alpha.color = Color::Red().WithAlpha(0.5);
 
  canvas.SaveLayer(alpha);
 
  canvas.DrawCircle({125, 125}, 125, red);
 
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [108/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanvasCanPushPopCTM
	)

Definition at line 57 of file aiks_unittests.cc.

                                      {
  Canvas canvas;
  ASSERT_EQ(canvas.GetSaveCount(), 1u);
  ASSERT_EQ(canvas.Restore(), false);
 
  canvas.Translate(Size{100, 100});
  canvas.Save();
  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}));
}

◆ TEST_P() [109/450]

impeller::testing::TEST_P	(	AiksTest	,
		CanvasCTMCanBeUpdated
	)

Definition at line 48 of file aiks_unittests.cc.

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

◆ TEST_P() [110/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClearBlend
	)

Definition at line 356 of file aiks_blend_unittests.cc.

                             {
  Canvas canvas;
  Paint white;
  white.color = Color::Blue();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600.0, 600.0), white);
 
  Paint clear;
  clear.blend_mode = BlendMode::kClear;
 
  canvas.DrawCircle(Point::MakeXY(300.0, 300.0), 200.0, clear);
}

◆ TEST_P() [111/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClearBlendWithBlur
	)

Definition at line 183 of file aiks_blur_unittests.cc.

                                     {
  Canvas canvas;
  Paint white;
  white.color = Color::Blue();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 600.0, 600.0), white);
 
  Paint clear;
  clear.blend_mode = BlendMode::kClear;
  clear.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kNormal,
      .sigma = Sigma(20),
  };
 
  canvas.DrawCircle(Point::MakeXY(300.0, 300.0), 200.0, clear);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [112/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClearColorOptimizationDoesNotApplyForBackdropFilters
	)

Definition at line 1707 of file aiks_unittests.cc.

                                                                       {
  Canvas canvas;
  canvas.SaveLayer({}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(3), Sigma(3),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
                    .blend_mode = BlendMode::kSourceOver});
  canvas.Restore();
 
  Picture picture = canvas.EndRecordingAsPicture();
 
  std::optional<Color> actual_color;
  bool found_subpass = false;
  picture.pass->IterateAllElements([&](EntityPass::Element& element) -> bool {
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      actual_color = subpass->get()->GetClearColor();
      found_subpass = true;
    }
    // Fail if the first element isn't a subpass.
    return true;
  });
 
  EXPECT_TRUE(found_subpass);
  EXPECT_FALSE(actual_color.has_value());
}

◆ TEST_P() [113/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClearColorOptimizationWhenSubpassIsBiggerThanParentPass
	)

Definition at line 2511 of file aiks_unittests.cc.

                                                                          {
  SetWindowSize({400, 400});
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.DrawRect(Rect::MakeLTRB(200, 200, 300, 300), {.color = Color::Red()});
  canvas.SaveLayer({
      .image_filter = std::make_shared<MatrixImageFilter>(
          Matrix::MakeScale({2, 2, 1}), SamplerDescriptor{}),
  });
  // Draw a rectangle that would fully cover the parent pass size, but not
  // the subpass that it is rendered in.
  canvas.DrawRect(Rect::MakeLTRB(0, 0, 400, 400), {.color = Color::Green()});
  // Draw a bigger rectangle to force the subpass to be bigger.
  canvas.DrawRect(Rect::MakeLTRB(0, 0, 800, 800), {.color = Color::Red()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [114/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBlurFilterRendersCorrectly
	)

Definition at line 168 of file aiks_blur_unittests.cc.

                                                    {
  Canvas canvas;
  canvas.Translate(Point(0, -400));
  Paint paint;
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kNormal,
      .sigma = Radius{120 * 3},
  };
  paint.color = Color::Red();
  PathBuilder builder{};
  builder.AddRect(Rect::MakeLTRB(0, 0, 800, 800));
  canvas.DrawPath(builder.TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [115/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBlurFilterRendersCorrectlyInteractive
	)

Definition at line 146 of file aiks_blur_unittests.cc.

                                                               {
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    static PlaygroundPoint playground_point(Point(400, 400), 20,
                                            Color::Green());
    auto point = DrawPlaygroundPoint(playground_point);
 
    Canvas canvas;
    canvas.Translate(point - Point(400, 400));
    Paint paint;
    paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
        .style = FilterContents::BlurStyle::kNormal,
        .sigma = Radius{120 * 3},
    };
    paint.color = Color::Red();
    PathBuilder builder{};
    builder.AddRect(Rect::MakeLTRB(0, 0, 800, 800));
    canvas.DrawPath(builder.TakePath(), paint);
    return canvas.EndRecordingAsPicture();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [116/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClipRectElidesNoOpClips
	)

Definition at line 1683 of file aiks_unittests.cc.

                                          {
  Canvas canvas(Rect::MakeXYWH(0, 0, 100, 100));
  canvas.ClipRect(Rect::MakeXYWH(0, 0, 100, 100));
  canvas.ClipRect(Rect::MakeXYWH(-100, -100, 300, 300));
  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
                    .blend_mode = BlendMode::kSourceOver});
 
  Picture picture = canvas.EndRecordingAsPicture();
  auto expected = Color::Red().Blend(Color::CornflowerBlue().WithAlpha(0.75),
                                     BlendMode::kSourceOver);
  ASSERT_EQ(picture.pass->GetClearColor(), expected);
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
 
  ASSERT_EQ(spy->render_passes_.size(), 1llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
}

◆ TEST_P() [117/450]

impeller::testing::TEST_P	(	AiksTest	,
		ClipsUseCurrentTransform
	)

Definition at line 102 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(CreateCircle(0, 0, 300));
    builder.DrawRect(SkRect::MakeXYWH(-300, -300, 600, 600), paint);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [118/450]

impeller::testing::TEST_P	(	AiksTest	,
		CollapsedDrawPaintInSubpass
	)

Definition at line 1735 of file aiks_unittests.cc.

                                              {
  Canvas canvas;
  canvas.DrawPaint(
      {.color = Color::Yellow(), .blend_mode = BlendMode::kSource});
  canvas.SaveLayer({.blend_mode = BlendMode::kMultiply});
  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
                    .blend_mode = BlendMode::kSourceOver});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [119/450]

impeller::testing::TEST_P	(	AiksTest	,
		CollapsedDrawPaintInSubpassBackdropFilter
	)

Definition at line 1746 of file aiks_unittests.cc.

                                                            {
  // Bug: https://github.com/flutter/flutter/issues/131576
  Canvas canvas;
  canvas.DrawPaint(
      {.color = Color::Yellow(), .blend_mode = BlendMode::kSource});
  canvas.SaveLayer({}, {},
                   ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kDecal));
  canvas.DrawPaint(
      {.color = Color::CornflowerBlue(), .blend_mode = BlendMode::kSourceOver});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [120/450]

impeller::testing::TEST_P	(	AiksTest	,
		ColorMatrixFilterSubpassCollapseOptimization
	)

Definition at line 1761 of file aiks_unittests.cc.

                                                               {
  Canvas canvas;
 
  canvas.SaveLayer({
      .color_filter =
          ColorFilter::MakeMatrix({.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   //
                                       }}),
  });
 
  canvas.Translate({500, 300, 0});
  canvas.Rotate(Radians(2 * kPi / 3));
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [121/450]

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 205 of file aiks_blend_unittests.cc.

                             {
  // Compare with https://fiddle.skia.org/c/@BlendModes
 
  BlendModeSelection blend_modes = GetBlendModeSelection();
 
  auto draw_color_wheel = [](Canvas& canvas) {
    /// 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);
    };
 
    Paint paint;
    paint.blend_mode = BlendMode::kSourceOver;
 
    // 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;
 
      paint.color =
          color_wheel_sampler(r).WithAlpha(1.0f - normalized_distance);
      Point position(distance * std::sin(r.radians),
                     -distance * std::cos(r.radians));
 
      canvas.DrawCircle(position, 9 + normalized_distance * 3, paint);
    }
  };
 
  std::shared_ptr<Image> color_wheel_image;
  Matrix color_wheel_transform;
 
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    // 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 Color color0 = Color::Red();
    static Color color1 = Color::Green();
    static Color color2 = Color::Blue();
 
    if (AiksTest::ImGuiBegin("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();
    }
 
    static Point content_scale;
    Point new_content_scale = GetContentScale();
 
    if (!cache_the_wheel || new_content_scale != content_scale) {
      content_scale = new_content_scale;
 
      // Render the color wheel to an image.
 
      Canvas canvas;
      canvas.Scale(content_scale);
 
      canvas.Translate(Vector2(500, 400));
      canvas.Scale(Vector2(3, 3));
 
      draw_color_wheel(canvas);
      auto color_wheel_picture = canvas.EndRecordingAsPicture();
      auto snapshot = color_wheel_picture.Snapshot(renderer);
      if (!snapshot.has_value() || !snapshot->texture) {
        return std::nullopt;
      }
      color_wheel_image = std::make_shared<Image>(snapshot->texture);
      color_wheel_transform = snapshot->transform;
    }
 
    Canvas canvas;
 
    // Blit the color wheel backdrop to the screen with managed alpha.
    canvas.SaveLayer({.color = Color::White().WithAlpha(dst_alpha),
                      .blend_mode = BlendMode::kSource});
    {
      canvas.DrawPaint({.color = Color::White()});
 
      canvas.Save();
      canvas.Transform(color_wheel_transform);
      canvas.DrawImage(color_wheel_image, Point(), Paint());
      canvas.Restore();
    }
    canvas.Restore();
 
    canvas.Scale(content_scale);
    canvas.Translate(Vector2(500, 400));
    canvas.Scale(Vector2(3, 3));
 
    // Draw 3 circles to a subpass and blend it in.
    canvas.SaveLayer(
        {.color = Color::White().WithAlpha(src_alpha),
         .blend_mode = blend_modes.blend_mode_values[current_blend_index]});
    {
      Paint paint;
      paint.blend_mode = BlendMode::kPlus;
      const Scalar x = std::sin(k2Pi / 3);
      const Scalar y = -std::cos(k2Pi / 3);
      paint.color = color0;
      canvas.DrawCircle(Point(-x, y) * 45, 65, paint);
      paint.color = color1;
      canvas.DrawCircle(Point(0, -1) * 45, 65, paint);
      paint.color = color2;
      canvas.DrawCircle(Point(x, y) * 45, 65, paint);
    }
    canvas.Restore();
 
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [122/450]

impeller::testing::TEST_P	(	AiksTest	,
		CoordinateConversionsAreCorrect
	)

Definition at line 404 of file aiks_unittests.cc.

                                                  {
  Canvas canvas;
 
  // Render a texture directly.
  {
    Paint paint;
    auto image =
        std::make_shared<Image>(CreateTextureForFixture("kalimba.jpg"));
    paint.color = Color::Red();
 
    canvas.Save();
    canvas.Translate({100, 200, 0});
    canvas.Scale(Vector2{0.5, 0.5});
    canvas.DrawImage(image, Point::MakeXY(100.0, 100.0), paint);
    canvas.Restore();
  }
 
  // Render an offscreen rendered texture.
  {
    Paint red;
    red.color = Color::Red();
    Paint green;
    green.color = Color::Green();
    Paint blue;
    blue.color = Color::Blue();
 
    Paint alpha;
    alpha.color = Color::Red().WithAlpha(0.5);
 
    canvas.SaveLayer(alpha);
 
    canvas.DrawRect(Rect::MakeXYWH(000, 000, 100, 100), red);
    canvas.DrawRect(Rect::MakeXYWH(020, 020, 100, 100), green);
    canvas.DrawRect(Rect::MakeXYWH(040, 040, 100, 100), blue);
 
    canvas.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [123/450]

impeller::testing::TEST_P	(	AiksTest	,
		CorrectClipDepthAssignedToEntities
	)

Definition at line 2620 of file aiks_unittests.cc.

                                                     {
  Canvas canvas;  // Depth 1 (base pass)
  canvas.DrawRRect(Rect::MakeLTRB(0, 0, 100, 100), {10, 10}, {});  // Depth 2
  canvas.Save();
  {
    canvas.ClipRRect(Rect::MakeLTRB(0, 0, 50, 50), {10, 10}, {});  // Depth 4
    canvas.SaveLayer({});                                          // Depth 4
    {
      canvas.DrawRRect(Rect::MakeLTRB(0, 0, 50, 50), {10, 10}, {});  // Depth 3
    }
    canvas.Restore();  // Restore the savelayer.
  }
  canvas.Restore();  // Depth 5 -- this will no longer append a restore entity
                     //            once we switch to the clip depth approach.
 
  auto picture = canvas.EndRecordingAsPicture();
 
  std::vector<uint32_t> expected = {
      2,  // DrawRRect
      4,  // ClipRRect -- Has a depth value equal to the max depth of all the
          //              content it affect. In this case, the SaveLayer and all
          //              its contents are affected.
      4,  // SaveLayer -- The SaveLayer is drawn to the parent pass after its
          //              contents are rendered, so it should have a depth value
          //              greater than all its contents.
      3,  // DrawRRect
      5,  // Restore (no longer necessary when clipping on the depth buffer)
  };
 
  std::vector<uint32_t> actual;
 
  picture.pass->IterateAllElements([&](EntityPass::Element& element) -> bool {
    if (auto* subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      actual.push_back(subpass->get()->GetClipDepth());
    }
    if (Entity* entity = std::get_if<Entity>(&element)) {
      actual.push_back(entity->GetClipDepth());
    }
    return true;
  });
 
  ASSERT_EQ(actual.size(), expected.size());
  for (size_t i = 0; i < expected.size(); i++) {
    EXPECT_EQ(expected[i], actual[i]) << "Index: " << i;
  }
}

◆ TEST_P() [124/450]

impeller::testing::TEST_P	(	AiksTest	,
		CoverageOriginShouldBeAccountedForInSubpasses
	)

Definition at line 1339 of file aiks_unittests.cc.

                                                                {
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    Canvas canvas;
    canvas.Scale(GetContentScale());
 
    Paint alpha;
    alpha.color = Color::Red().WithAlpha(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);
    auto bounds = Rect::MakeLTRB(b0.x, b0.y, b1.x, b1.y);
 
    canvas.DrawRect(bounds, Paint{.color = Color::Yellow(),
                                  .stroke_width = 5.0f,
                                  .style = Paint::Style::kStroke});
 
    canvas.SaveLayer(alpha, bounds);
 
    canvas.DrawRect(Rect::MakeOriginSize(current, size),
                    Paint{.color = Color::Red()});
    canvas.DrawRect(Rect::MakeOriginSize(current += offset, size),
                    Paint{.color = Color::Green()});
    canvas.DrawRect(Rect::MakeOriginSize(current += offset, size),
                    Paint{.color = Color::Blue()});
 
    canvas.Restore();
 
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [125/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAdvancedBlendPartlyOffscreen
	)

Definition at line 94 of file aiks_blend_unittests.cc.

                                                   {
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.1294, 0.5882, 0.9529, 1.0}};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  Paint paint = {
      .color_source = ColorSource::MakeLinearGradient(
          {0, 0}, {100, 100}, std::move(colors), std::move(stops),
          Entity::TileMode::kRepeat, Matrix::MakeScale(Vector3(0.3, 0.3, 0.3))),
      .blend_mode = BlendMode::kLighten,
  };
 
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Blue()});
  canvas.Scale(Vector2(2, 2));
  canvas.ClipRect(Rect::MakeLTRB(0, 0, 200, 200));
  canvas.DrawCircle({100, 100}, 100, paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [126/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasAdvancedAndTransform
	)

Definition at line 129 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()));
}

◆ TEST_P() [127/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasNoColor
	)

Definition at line 52 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()));
}

◆ TEST_P() [128/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasNoColorFullSize
	)

Definition at line 112 of file aiks_dl_atlas_unittests.cc.

                                           {
  auto atlas = DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
  auto size = atlas->impeller_texture()->GetSize();
  std::vector<SkRect> texture_coordinates = {
      SkRect::MakeLTRB(0, 0, size.width, size.height)};
  std::vector<SkRSXform> 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()));
}

◆ TEST_P() [129/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasPlusWideGamut
	)

Definition at line 158 of file aiks_dl_atlas_unittests.cc.

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

◆ TEST_P() [130/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorAdvanced
	)

Definition at line 64 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()));
}

◆ TEST_P() [131/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorAdvancedAndTransform
	)

Definition at line 143 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()));
}

◆ TEST_P() [132/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorSimple
	)

Definition at line 79 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()));
}

◆ TEST_P() [133/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithOpacity
	)

Definition at line 95 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()));
}

◆ TEST_P() [134/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesRenderCorrectly
	)

Definition at line 256 of file aiks_path_unittests.cc.

                                           {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  paint.color = Color::Blue();
  paint.stroke_width = 10;
 
  auto draw = [&canvas](Paint& paint) {
    for (auto cap : {Cap::kButt, Cap::kSquare, Cap::kRound}) {
      paint.stroke_cap = cap;
      Point origin = {100, 100};
      Point p0 = {50, 0};
      Point p1 = {150, 0};
      canvas.DrawLine({150, 100}, {250, 100}, paint);
      for (int d = 15; d < 90; d += 15) {
        Matrix m = Matrix::MakeRotationZ(Degrees(d));
        canvas.DrawLine(origin + m * p0, origin + m * p1, paint);
      }
      canvas.DrawLine({100, 150}, {100, 250}, paint);
      canvas.DrawCircle({origin}, 35, paint);
 
      canvas.DrawLine({250, 250}, {250, 250}, paint);
 
      canvas.Translate({250, 0});
    }
    canvas.Translate({-750, 250});
  };
 
  std::vector<Color> colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  draw(paint);
 
  paint.color_source = ColorSource::MakeRadialGradient(
      {100, 100}, 200, std::move(colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  draw(paint);
 
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({-150, 75}));
  draw(paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [135/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawOpacityPeephole
	)

Definition at line 19 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(nullptr, &alpha);
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 100, 100), green);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [136/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintAbsorbsClears
	)

Definition at line 1556 of file aiks_unittests.cc.

                                         {
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
                    .blend_mode = BlendMode::kSourceOver});
 
  Picture picture = canvas.EndRecordingAsPicture();
  auto expected = Color::Red().Blend(Color::CornflowerBlue().WithAlpha(0.75),
                                     BlendMode::kSourceOver);
  ASSERT_EQ(picture.pass->GetClearColor(), expected);
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
 
  ASSERT_EQ(spy->render_passes_.size(), 1llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
}

◆ TEST_P() [137/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintTransformsBounds
	)

Definition at line 2176 of file aiks_unittests.cc.

                                            {
  auto runtime_stages = OpenAssetAsRuntimeStage("gradient.frag.iplr");
  auto runtime_stage =
      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  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));
 
  std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
 
  Paint paint;
  paint.color_source = ColorSource::MakeRuntimeEffect(
      runtime_stage, uniform_data, texture_inputs);
 
  Canvas canvas;
  canvas.Save();
  canvas.Scale(GetContentScale());
  canvas.DrawPaint(paint);
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [138/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintWithAdvancedBlendOverFilter
	)

Definition at line 77 of file aiks_blend_unittests.cc.

                                                       {
  Paint filtered = {
      .color = Color::Black(),
      .mask_blur_descriptor =
          Paint::MaskBlurDescriptor{
              .style = FilterContents::BlurStyle::kNormal,
              .sigma = Sigma(60),
          },
  };
 
  Canvas canvas;
  canvas.DrawPaint({.color = Color::White()});
  canvas.DrawCircle({300, 300}, 200, filtered);
  canvas.DrawPaint({.color = Color::Green(), .blend_mode = BlendMode::kScreen});
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [139/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectAbsorbsClears
	)

Definition at line 1603 of file aiks_unittests.cc.

                                        {
  Canvas canvas;
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
                  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
                  {.color = Color::CornflowerBlue().WithAlpha(0.75),
                   .blend_mode = BlendMode::kSourceOver});
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
 
  ASSERT_EQ(spy->render_passes_.size(), 1llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
}

◆ TEST_P() [140/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectAbsorbsClearsNegative
	)

Definition at line 1663 of file aiks_unittests.cc.

                                                {
  Canvas canvas;
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
                  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
                  {.color = Color::CornflowerBlue().WithAlpha(0.75),
                   .blend_mode = BlendMode::kSourceOver});
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {301, 301});
 
  ASSERT_EQ(spy->render_passes_.size(), 1llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 2llu);
}

◆ TEST_P() [141/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectAbsorbsClearsNegativeRotation
	)

Definition at line 1643 of file aiks_unittests.cc.

                                                        {
  Canvas canvas;
  canvas.Translate(Vector3(150.0, 150.0, 0.0));
  canvas.Rotate(Degrees(45.0));
  canvas.Translate(Vector3(-150.0, -150.0, 0.0));
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 300, 300),
                  {.color = Color::Red(), .blend_mode = BlendMode::kSource});
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
 
  ASSERT_EQ(spy->render_passes_.size(), 1llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 1llu);
}

◆ TEST_P() [142/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectAbsorbsClearsNegativeRRect
	)

Definition at line 1623 of file aiks_unittests.cc.

                                                     {
  Canvas canvas;
  canvas.DrawRRect(Rect::MakeXYWH(0, 0, 300, 300), {5.0, 5.0},
                   {.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawRRect(Rect::MakeXYWH(0, 0, 300, 300), {5.0, 5.0},
                   {.color = Color::CornflowerBlue().WithAlpha(0.75),
                    .blend_mode = BlendMode::kSourceOver});
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
 
  ASSERT_EQ(spy->render_passes_.size(), 1llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 2llu);
}

◆ TEST_P() [143/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectStrokesRenderCorrectly
	)

Definition at line 320 of file aiks_path_unittests.cc.

                                                 {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 10;
 
  canvas.Translate({100, 100});
  canvas.DrawPath(
      PathBuilder{}.AddRect(Rect::MakeSize(Size{100, 100})).TakePath(),
      {paint});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [144/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectStrokesWithBevelJoinRenderCorrectly
	)

Definition at line 335 of file aiks_path_unittests.cc.

                                                              {
  Canvas canvas;
  Paint paint;
  paint.color = Color::Red();
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 10;
  paint.stroke_join = Join::kBevel;
 
  canvas.Translate({100, 100});
  canvas.DrawPath(
      PathBuilder{}.AddRect(Rect::MakeSize(Size{100, 100})).TakePath(),
      {paint});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [145/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawScaledTextWithPerspectiveNoSaveLayer
	)

Definition at line 2363 of file aiks_unittests.cc.

                                                           {
  Canvas canvas;
  canvas.Transform(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}}));
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), canvas, "Hello world",
                                     "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [146/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawScaledTextWithPerspectiveSaveLayer
	)

Definition at line 2377 of file aiks_unittests.cc.

                                                         {
  Canvas canvas;
  Paint save_paint;
  canvas.SaveLayer(save_paint);
  canvas.Transform(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}}));
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), canvas, "Hello world",
                                     "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [147/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesImageSourceWithTextureCoordinates
	)

Definition at line 259 of file aiks_dl_vertices_unittests.cc.

                                                                {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  auto dl_image = DlImageImpeller::Make(texture);
  std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
                                    SkPoint::Make(200, 100),
                                    SkPoint::Make(300, 300)};
  std::vector<SkPoint> texture_coordinates = {
      SkPoint::Make(0, 0), SkPoint::Make(100, 200), SkPoint::Make(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::DlImageColorSource(
      dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
 
  paint.setColorSource(&image_source);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [148/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesImageSourceWithTextureCoordinatesAndColorBlending
	)

Definition at line 284 of file aiks_dl_vertices_unittests.cc.

                                                                      {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  auto dl_image = DlImageImpeller::Make(texture);
  std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
                                    SkPoint::Make(200, 100),
                                    SkPoint::Make(300, 300)};
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kWhite(),
                                          flutter::DlColor::kGreen(),
                                          flutter::DlColor::kWhite()};
  std::vector<SkPoint> texture_coordinates = {
      SkPoint::Make(0, 0), SkPoint::Make(100, 200), SkPoint::Make(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::DlImageColorSource(
      dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
 
  paint.setColorSource(&image_source);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kModulate, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [149/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithoutIndices
	)

Definition at line 204 of file aiks_dl_vertices_unittests.cc.

                                                           {
  std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
                                    SkPoint::Make(200, 100),
                                    SkPoint::Make(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()));
}

◆ TEST_P() [150/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithTextureCoordinates
	)

Definition at line 230 of file aiks_dl_vertices_unittests.cc.

                                                                   {
  std::vector<SkPoint> positions = {SkPoint::Make(100, 300),
                                    SkPoint::Make(200, 100),
                                    SkPoint::Make(300, 300)};
  std::vector<SkPoint> texture_coordinates = {SkPoint::Make(300, 100),
                                              SkPoint::Make(100, 200),
                                              SkPoint::Make(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()));
}

◆ TEST_P() [151/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesPremultipliesColors
	)

Definition at line 333 of file aiks_dl_vertices_unittests.cc.

                                                  {
  std::vector<SkPoint> positions = {
      SkPoint::Make(100, 300), SkPoint::Make(200, 100), SkPoint::Make(300, 300),
      SkPoint::Make(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(SkRect::MakeLTRB(0, 0, 400, 400), paint);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kDst, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [152/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesSolidColorTrianglesWithIndices
	)

Definition at line 313 of file aiks_dl_vertices_unittests.cc.

                                                             {
  std::vector<SkPoint> positions = {
      SkPoint::Make(100, 300), SkPoint::Make(200, 100), SkPoint::Make(300, 300),
      SkPoint::Make(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()));
}

◆ TEST_P() [153/450]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesSolidColorTrianglesWithoutIndices
	)

Definition at line 180 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<SkPoint> positions = {SkPoint::Make(-100, -300),
                                    SkPoint::Make(-200, -100),
                                    SkPoint::Make(-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()));
}

◆ TEST_P() [154/450]

impeller::testing::TEST_P	(	AiksTest	,
		EmptySaveLayerIgnoresPaint
	)

Definition at line 2530 of file aiks_unittests.cc.

                                             {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.DrawPaint(Paint{.color = Color::Red()});
  canvas.ClipRect(Rect::MakeXYWH(100, 100, 200, 200));
  canvas.SaveLayer(Paint{.color = Color::Blue()});
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [155/450]

impeller::testing::TEST_P	(	AiksTest	,
		EmptySaveLayerRendersWithClear
	)

Definition at line 2540 of file aiks_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
  canvas.DrawImage(image, {10, 10}, {});
  canvas.ClipRect(Rect::MakeXYWH(100, 100, 200, 200));
  canvas.SaveLayer(Paint{.blend_mode = BlendMode::kClear});
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [156/450]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestHorizontal
	)

Definition at line 716 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(SkRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(0, 0, 300, 300), 4, 4),
                    paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [157/450]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestHorizontalReversed
	)

Definition at line 762 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(SkRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(0, 0, 300, 300), 4, 4),
                    paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [158/450]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestVertical
	)

Definition at line 739 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(SkRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(0, 0, 300, 300), 4, 4),
                    paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [159/450]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestVerticalReversed
	)

Definition at line 785 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(SkRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(0, 0, 300, 300), 4, 4),
                    paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [160/450]

impeller::testing::TEST_P	(	AiksTest	,
		FilledCirclesRenderCorrectly
	)

Definition at line 911 of file aiks_unittests.cc.

                                               {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  const int color_count = 3;
  Color colors[color_count] = {
      Color::Blue(),
      Color::Green(),
      Color::Crimson(),
  };
 
  paint.color = Color::White();
  canvas.DrawPaint(paint);
 
  int c_index = 0;
  int radius = 600;
  while (radius > 0) {
    paint.color = colors[(c_index++) % color_count];
    canvas.DrawCircle({10, 10}, radius, paint);
    if (radius > 30) {
      radius -= 10;
    } else {
      radius -= 2;
    }
  }
 
  std::vector<Color> gradient_colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  paint.color_source = ColorSource::MakeRadialGradient(
      {500, 600}, 75, std::move(gradient_colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  canvas.DrawCircle({500, 600}, 100, paint);
 
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({700, 200}));
  canvas.DrawCircle({800, 300}, 100, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [161/450]

impeller::testing::TEST_P	(	AiksTest	,
		FilledEllipsesRenderCorrectly
	)

Definition at line 1034 of file aiks_unittests.cc.

                                                {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  const int color_count = 3;
  Color colors[color_count] = {
      Color::Blue(),
      Color::Green(),
      Color::Crimson(),
  };
 
  paint.color = Color::White();
  canvas.DrawPaint(paint);
 
  int c_index = 0;
  int long_radius = 600;
  int short_radius = 600;
  while (long_radius > 0 && short_radius > 0) {
    paint.color = colors[(c_index++) % color_count];
    canvas.DrawOval(Rect::MakeXYWH(10 - long_radius, 10 - short_radius,
                                   long_radius * 2, short_radius * 2),
                    paint);
    canvas.DrawOval(Rect::MakeXYWH(1000 - short_radius, 750 - long_radius,
                                   short_radius * 2, long_radius * 2),
                    paint);
    if (short_radius > 30) {
      short_radius -= 10;
      long_radius -= 5;
    } else {
      short_radius -= 2;
      long_radius -= 1;
    }
  }
 
  std::vector<Color> gradient_colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  paint.color = Color::White().WithAlpha(0.5);
 
  paint.color_source = ColorSource::MakeRadialGradient(
      {300, 650}, 75, std::move(gradient_colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  canvas.DrawOval(Rect::MakeXYWH(200, 625, 200, 50), paint);
  canvas.DrawOval(Rect::MakeXYWH(275, 550, 50, 200), paint);
 
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({610, 15}));
  canvas.DrawOval(Rect::MakeXYWH(610, 90, 200, 50), paint);
  canvas.DrawOval(Rect::MakeXYWH(685, 15, 50, 200), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [162/450]

impeller::testing::TEST_P	(	AiksTest	,
		FilledRoundRectPathsRenderCorrectly
	)

Definition at line 1249 of file aiks_unittests.cc.

                                                      {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  const int color_count = 3;
  Color colors[color_count] = {
      Color::Blue(),
      Color::Green(),
      Color::Crimson(),
  };
 
  paint.color = Color::White();
  canvas.DrawPaint(paint);
 
  auto draw_rrect_as_path = [&canvas](const Rect& rect, const Size& radii,
                                      const Paint& paint) {
    PathBuilder builder = PathBuilder();
    builder.AddRoundedRect(rect, radii);
    canvas.DrawPath(builder.TakePath(), paint);
  };
 
  int c_index = 0;
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      paint.color = colors[(c_index++) % color_count];
      draw_rrect_as_path(Rect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),
                         Size(i * 5 + 10, j * 5 + 10), paint);
    }
  }
  paint.color = colors[(c_index++) % color_count];
  draw_rrect_as_path(Rect::MakeXYWH(10, 420, 380, 80), Size(40, 40), paint);
  paint.color = colors[(c_index++) % color_count];
  draw_rrect_as_path(Rect::MakeXYWH(410, 20, 80, 380), Size(40, 40), paint);
 
  std::vector<Color> gradient_colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  paint.color = Color::White().WithAlpha(0.1);
  paint.color_source = ColorSource::MakeRadialGradient(
      {550, 550}, 75, gradient_colors, stops, Entity::TileMode::kMirror, {});
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    draw_rrect_as_path(Rect::MakeLTRB(550 - i * 20, 550 - j * 20,  //
                                      550 + i * 20, 550 + j * 20),
                       Size(i * 10, j * 10), paint);
  }
  paint.color = Color::White().WithAlpha(0.5);
  paint.color_source = ColorSource::MakeRadialGradient(
      {200, 650}, 75, std::move(gradient_colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  draw_rrect_as_path(Rect::MakeLTRB(100, 610, 300, 690), Size(40, 40), paint);
  draw_rrect_as_path(Rect::MakeLTRB(160, 550, 240, 750), Size(40, 40), paint);
 
  paint.color = Color::White().WithAlpha(0.1);
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({520, 20}));
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    draw_rrect_as_path(Rect::MakeLTRB(720 - i * 20, 220 - j * 20,  //
                                      720 + i * 20, 220 + j * 20),
                       Size(i * 10, j * 10), paint);
  }
  paint.color = Color::White().WithAlpha(0.5);
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({800, 300}));
  draw_rrect_as_path(Rect::MakeLTRB(800, 410, 1000, 490), Size(40, 40), paint);
  draw_rrect_as_path(Rect::MakeLTRB(860, 350, 940, 550), Size(40, 40), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [163/450]

impeller::testing::TEST_P	(	AiksTest	,
		FilledRoundRectsRenderCorrectly
	)

Definition at line 1105 of file aiks_unittests.cc.

                                                  {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  const int color_count = 3;
  Color colors[color_count] = {
      Color::Blue(),
      Color::Green(),
      Color::Crimson(),
  };
 
  paint.color = Color::White();
  canvas.DrawPaint(paint);
 
  int c_index = 0;
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      paint.color = colors[(c_index++) % color_count];
      canvas.DrawRRect(Rect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),
                       Size(i * 5 + 10, j * 5 + 10), paint);
    }
  }
  paint.color = colors[(c_index++) % color_count];
  canvas.DrawRRect(Rect::MakeXYWH(10, 420, 380, 80), Size(40, 40), paint);
  paint.color = colors[(c_index++) % color_count];
  canvas.DrawRRect(Rect::MakeXYWH(410, 20, 80, 380), Size(40, 40), paint);
 
  std::vector<Color> gradient_colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  paint.color = Color::White().WithAlpha(0.1);
  paint.color_source = ColorSource::MakeRadialGradient(
      {550, 550}, 75, gradient_colors, stops, Entity::TileMode::kMirror, {});
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    canvas.DrawRRect(Rect::MakeLTRB(550 - i * 20, 550 - j * 20,  //
                                    550 + i * 20, 550 + j * 20),
                     Size(i * 10, j * 10), paint);
  }
  paint.color = Color::White().WithAlpha(0.5);
  paint.color_source = ColorSource::MakeRadialGradient(
      {200, 650}, 75, std::move(gradient_colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  canvas.DrawRRect(Rect::MakeLTRB(100, 610, 300, 690), Size(40, 40), paint);
  canvas.DrawRRect(Rect::MakeLTRB(160, 550, 240, 750), Size(40, 40), paint);
 
  paint.color = Color::White().WithAlpha(0.1);
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({520, 20}));
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    canvas.DrawRRect(Rect::MakeLTRB(720 - i * 20, 220 - j * 20,  //
                                    720 + i * 20, 220 + j * 20),
                     Size(i * 10, j * 10), paint);
  }
  paint.color = Color::White().WithAlpha(0.5);
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({800, 300}));
  canvas.DrawRRect(Rect::MakeLTRB(800, 410, 1000, 490), Size(40, 40), paint);
  canvas.DrawRRect(Rect::MakeLTRB(860, 350, 940, 550), Size(40, 40), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [164/450]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundAdvancedBlendAppliesTransformCorrectly
	)

Definition at line 566 of file aiks_blend_unittests.cc.

                                                                   {
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  Canvas canvas;
  canvas.Rotate(Degrees(30));
  canvas.DrawImage(std::make_shared<Image>(texture), {200, 200},
                   {.color_filter = ColorFilter::MakeBlend(
                        BlendMode::kColorDodge, Color::Orange())});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [165/450]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundBlendSubpassCollapseOptimization
	)

Definition at line 341 of file aiks_blend_unittests.cc.

                                                             {
  Canvas canvas;
 
  canvas.SaveLayer({
      .color_filter =
          ColorFilter::MakeBlend(BlendMode::kColorDodge, Color::Red()),
  });
 
  canvas.Translate({500, 300, 0});
  canvas.Rotate(Radians(2 * kPi / 3));
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [166/450]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundPipelineBlendAppliesTransformCorrectly
	)

Definition at line 553 of file aiks_blend_unittests.cc.

                                                                   {
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  Canvas canvas;
  canvas.Rotate(Degrees(30));
  canvas.DrawImage(std::make_shared<Image>(texture), {200, 200},
                   {.color_filter = ColorFilter::MakeBlend(BlendMode::kSourceIn,
                                                           Color::Orange())});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [167/450]

impeller::testing::TEST_P	(	AiksTest	,
		FormatSRGB
	)

Definition at line 864 of file aiks_unittests.cc.

                             {
  PixelFormat pixel_format =
      GetContext()->GetCapabilities()->GetDefaultColorFormat();
  EXPECT_TRUE(pixel_format == PixelFormat::kR8G8B8A8UNormInt ||
              pixel_format == PixelFormat::kB8G8R8A8UNormInt)
      << "pixel format: " << PixelFormatToString(pixel_format);
}

◆ TEST_P() [168/450]

impeller::testing::TEST_P	(	AiksTest	,
		FormatWideGamut
	)

Definition at line 859 of file aiks_unittests.cc.

                                  {
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
}

◆ TEST_P() [169/450]

impeller::testing::TEST_P	(	AiksTest	,
		FramebufferAdvancedBlendCoverage
	)

Definition at line 579 of file aiks_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.
  Canvas canvas;
  canvas.DrawPaint({.color = Color::DarkGray()});
  canvas.Scale(Vector2(0.4, 0.4));
  canvas.DrawImage(std::make_shared<Image>(texture), {20, 20},
                   {.blend_mode = BlendMode::kMultiply});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [170/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAllocatesCorrectMipCountRenderTarget
	)

Definition at line 1057 of file aiks_blur_unittests.cc.

                                                                   {
  size_t blur_required_mip_count =
      GetParam() == PlaygroundBackend::kOpenGLES ? 1 : 4;
 
  Canvas canvas;
  canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
  canvas.SaveLayer({}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(3), Sigma(3),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
 
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<RenderTargetCache> cache =
      std::make_shared<RenderTargetCache>(GetContext()->GetResourceAllocator());
  AiksContext aiks_context(GetContext(), nullptr, cache);
  picture.ToImage(aiks_context, {100, 100});
 
  size_t max_mip_count = 0;
  for (auto it = cache->GetRenderTargetDataBegin();
       it != cache->GetRenderTargetDataEnd(); ++it) {
    max_mip_count = std::max(it->config.mip_count, max_mip_count);
  }
  EXPECT_EQ(max_mip_count, blur_required_mip_count);
}

◆ TEST_P() [171/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAnimatedBackdrop
	)

Definition at line 763 of file aiks_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 = std::make_shared<Image>(
      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 = [&](AiksContext& renderer) -> std::optional<Picture> {
    if (AiksTest::ImGuiBegin("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();
    }
 
    Canvas canvas;
    canvas.Scale(GetContentScale());
    Scalar y = amp * sin(freq * 2.0 * M_PI * count / 60);
    canvas.DrawImage(boston,
                     Point(1024 / 2 - boston->GetSize().width / 2,
                           (768 / 2 - boston->GetSize().height / 2) + y),
                     {});
    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);
    canvas.ClipRect(
        Rect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
    canvas.ClipRect(Rect::MakeLTRB(100, 100, 900, 700));
    canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                     ImageFilter::MakeBlur(Sigma(sigma), Sigma(sigma),
                                           FilterContents::BlurStyle::kNormal,
                                           Entity::TileMode::kClamp));
    count += 1;
    return canvas.EndRecordingAsPicture();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [172/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAtPeripheryHorizontal
	)

Definition at line 479 of file aiks_blur_unittests.cc.

                                                    {
  Canvas canvas;
 
  canvas.Scale(GetContentScale());
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  canvas.DrawImageRect(
      std::make_shared<Image>(boston),
      Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height),
      Rect::MakeLTRB(0, 0, GetWindowSize().width, 100), Paint{});
  canvas.DrawRRect(Rect::MakeLTRB(0, 110, GetWindowSize().width, 210),
                   Size(10, 10), Paint{.color = Color::Magenta()});
  canvas.ClipRect(Rect::MakeLTRB(0, 50, GetWindowSize().width, 150));
  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [173/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAtPeripheryVertical
	)

Definition at line 461 of file aiks_blur_unittests.cc.

                                                  {
  Canvas canvas;
 
  canvas.Scale(GetContentScale());
  canvas.DrawRRect(Rect::MakeLTRB(0, 0, GetWindowSize().width, 100),
                   Size(10, 10), Paint{.color = Color::LimeGreen()});
  canvas.DrawRRect(Rect::MakeLTRB(0, 110, GetWindowSize().width, 210),
                   Size(10, 10), Paint{.color = Color::Magenta()});
  canvas.ClipRect(Rect::MakeLTRB(100, 0, 200, GetWindowSize().height));
  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [174/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurBackdropTinyMipMap
	)

Definition at line 737 of file aiks_blur_unittests.cc.

                                                 {
  for (int32_t i = 0; i < 5; ++i) {
    Canvas canvas;
    ISize clip_size = ISize(i, i);
    canvas.ClipRect(
        Rect::MakeXYWH(400, 400, clip_size.width, clip_size.height));
    canvas.DrawCircle(
        {400, 400}, 200,
        {
            .color = Color::Green(),
            .image_filter = ImageFilter::MakeBlur(
                Sigma(0.1), Sigma(0.1), FilterContents::BlurStyle::kNormal,
                Entity::TileMode::kDecal),
        });
    canvas.Restore();
 
    Picture picture = canvas.EndRecordingAsPicture();
    std::shared_ptr<RenderTargetCache> cache =
        std::make_shared<RenderTargetCache>(
            GetContext()->GetResourceAllocator());
    AiksContext aiks_context(GetContext(), nullptr, cache);
    std::shared_ptr<Image> image = picture.ToImage(aiks_context, {1024, 768});
    EXPECT_TRUE(image) << " clip rect " << i;
  }
}

◆ TEST_P() [175/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurMipMapImageFilter
	)

Definition at line 1122 of file aiks_blur_unittests.cc.

                                                {
  size_t blur_required_mip_count =
      GetParam() == PlaygroundBackend::kOpenGLES ? 1 : 4;
  fml::testing::LogCapture log_capture;
  Canvas canvas;
  canvas.SaveLayer(
      {.image_filter = ImageFilter::MakeBlur(Sigma(30), Sigma(30),
                                             FilterContents::BlurStyle::kNormal,
                                             Entity::TileMode::kClamp)});
  canvas.DrawCircle({200, 200}, 50, {.color = Color::Chartreuse()});
 
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<RenderTargetCache> cache =
      std::make_shared<RenderTargetCache>(GetContext()->GetResourceAllocator());
  AiksContext aiks_context(GetContext(), nullptr, cache);
  picture.ToImage(aiks_context, {1024, 768});
 
  size_t max_mip_count = 0;
  for (auto it = cache->GetRenderTargetDataBegin();
       it != cache->GetRenderTargetDataEnd(); ++it) {
    max_mip_count = std::max(it->config.mip_count, max_mip_count);
  }
  EXPECT_EQ(max_mip_count, blur_required_mip_count);
  // The log is FML_DLOG, so only check in debug builds.
#ifndef NDEBUG
  if (GetParam() != PlaygroundBackend::kOpenGLES) {
    EXPECT_EQ(log_capture.str().find(GaussianBlurFilterContents::kNoMipsError),
              std::string::npos);
  } else {
    EXPECT_NE(log_capture.str().find(GaussianBlurFilterContents::kNoMipsError),
              std::string::npos);
  }
#endif
}

◆ TEST_P() [176/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurMipMapNestedLayer
	)

Definition at line 1083 of file aiks_blur_unittests.cc.

                                                {
  fml::testing::LogCapture log_capture;
  size_t blur_required_mip_count =
      GetParam() == PlaygroundBackend::kOpenGLES ? 1 : 4;
 
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Wheat()});
  canvas.SaveLayer({.blend_mode = BlendMode::kMultiply});
  canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
  canvas.SaveLayer({}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(30), Sigma(30),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.DrawCircle({200, 200}, 50, {.color = Color::Chartreuse()});
 
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<RenderTargetCache> cache =
      std::make_shared<RenderTargetCache>(GetContext()->GetResourceAllocator());
  AiksContext aiks_context(GetContext(), nullptr, cache);
  picture.ToImage(aiks_context, {100, 100});
 
  size_t max_mip_count = 0;
  for (auto it = cache->GetRenderTargetDataBegin();
       it != cache->GetRenderTargetDataEnd(); ++it) {
    max_mip_count = std::max(it->config.mip_count, max_mip_count);
  }
  EXPECT_EQ(max_mip_count, blur_required_mip_count);
  // The log is FML_DLOG, so only check in debug builds.
#ifndef NDEBUG
  if (GetParam() != PlaygroundBackend::kOpenGLES) {
    EXPECT_EQ(log_capture.str().find(GaussianBlurFilterContents::kNoMipsError),
              std::string::npos);
  } else {
    EXPECT_NE(log_capture.str().find(GaussianBlurFilterContents::kNoMipsError),
              std::string::npos);
  }
#endif
}

◆ TEST_P() [177/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurMipMapSolidColor
	)

Definition at line 1157 of file aiks_blur_unittests.cc.

                                               {
  size_t blur_required_mip_count =
      GetParam() == PlaygroundBackend::kOpenGLES ? 1 : 4;
  fml::testing::LogCapture log_capture;
  Canvas canvas;
  canvas.DrawPath(PathBuilder{}
                      .MoveTo({100, 100})
                      .LineTo({200, 100})
                      .LineTo({150, 200})
                      .LineTo({50, 200})
                      .Close()
                      .TakePath(),
                  {.color = Color::Chartreuse(),
                   .image_filter = ImageFilter::MakeBlur(
                       Sigma(30), Sigma(30), FilterContents::BlurStyle::kNormal,
                       Entity::TileMode::kClamp)});
 
  Picture picture = canvas.EndRecordingAsPicture();
  std::shared_ptr<RenderTargetCache> cache =
      std::make_shared<RenderTargetCache>(GetContext()->GetResourceAllocator());
  AiksContext aiks_context(GetContext(), nullptr, cache);
  picture.ToImage(aiks_context, {1024, 768});
 
  size_t max_mip_count = 0;
  for (auto it = cache->GetRenderTargetDataBegin();
       it != cache->GetRenderTargetDataEnd(); ++it) {
    max_mip_count = std::max(it->config.mip_count, max_mip_count);
  }
  EXPECT_EQ(max_mip_count, blur_required_mip_count);
  // The log is FML_DLOG, so only check in debug builds.
#ifndef NDEBUG
  if (GetParam() != PlaygroundBackend::kOpenGLES) {
    EXPECT_EQ(log_capture.str().find(GaussianBlurFilterContents::kNoMipsError),
              std::string::npos);
  } else {
    EXPECT_NE(log_capture.str().find(GaussianBlurFilterContents::kNoMipsError),
              std::string::npos);
  }
#endif
}

◆ TEST_P() [178/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurOneDimension
	)

Definition at line 551 of file aiks_blur_unittests.cc.

                                           {
  Canvas canvas;
 
  canvas.Scale(GetContentScale());
  canvas.Scale({0.5, 0.5, 1.0});
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  canvas.DrawImage(std::make_shared<Image>(boston), Point(100, 100), Paint{});
  canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(50.0), Sigma(0.0),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [179/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedAndClipped
	)

Definition at line 570 of file aiks_blur_unittests.cc.

                                                {
  Canvas canvas;
  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);
  Paint paint = {.image_filter =
                     ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                           FilterContents::BlurStyle::kNormal,
                                           Entity::TileMode::kDecal)};
  Vector2 clip_size = {150, 75};
  Vector2 center = Vector2(1024, 768) / 2;
  canvas.Scale(GetContentScale());
  canvas.ClipRect(
      Rect::MakeLTRB(center.x, center.y, center.x, center.y).Expand(clip_size));
  canvas.Translate({center.x, center.y, 0});
  canvas.Scale({0.6, 0.6, 1});
  canvas.Rotate(Degrees(25));
 
  canvas.DrawImageRect(std::make_shared<Image>(boston), /*source=*/bounds,
                       /*dest=*/bounds.Shift(-image_center), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [180/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedAndClippedInteractive
	)

Definition at line 619 of file aiks_blur_unittests.cc.

                                                           {
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
 
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const Entity::TileMode tile_modes[] = {
        Entity::TileMode::kClamp, Entity::TileMode::kRepeat,
        Entity::TileMode::kMirror, Entity::TileMode::kDecal};
 
    static float rotation = 0;
    static float scale = 0.6;
    static int selected_tile_mode = 3;
 
    if (AiksTest::ImGuiBegin("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();
    }
 
    Canvas canvas;
    Rect bounds =
        Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
    Vector2 image_center = Vector2(bounds.GetSize() / 2);
    Paint paint = {.image_filter =
                       ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                             FilterContents::BlurStyle::kNormal,
                                             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;
    canvas.Scale(GetContentScale());
    canvas.ClipRect(
        Rect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
    canvas.Translate({center.x, center.y, 0});
    canvas.Scale({scale, scale, 1});
    canvas.Rotate(Degrees(rotation));
 
    canvas.DrawImageRect(std::make_shared<Image>(boston), /*source=*/bounds,
                         /*dest=*/bounds.Shift(-image_center), paint);
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [181/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedNonUniform
	)

Definition at line 668 of file aiks_blur_unittests.cc.

                                                {
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const Entity::TileMode tile_modes[] = {
        Entity::TileMode::kClamp, Entity::TileMode::kRepeat,
        Entity::TileMode::kMirror, Entity::TileMode::kDecal};
 
    static float rotation = 45;
    static float scale = 0.6;
    static int selected_tile_mode = 3;
 
    if (AiksTest::ImGuiBegin("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();
    }
 
    Canvas canvas;
    Paint paint = {.color = Color::Green(),
                   .image_filter =
                       ImageFilter::MakeBlur(Sigma(50.0), Sigma(0.0),
                                             FilterContents::BlurStyle::kNormal,
                                             tile_modes[selected_tile_mode])};
    Vector2 center = Vector2(1024, 768) / 2;
    canvas.Scale(GetContentScale());
    canvas.Translate({center.x, center.y, 0});
    canvas.Scale({scale, scale, 1});
    canvas.Rotate(Degrees(rotation));
 
    canvas.DrawRRect(Rect::MakeXYWH(-100, -100, 200, 200), Size(10, 10), paint);
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [182/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurScaledAndClipped
	)

Definition at line 595 of file aiks_blur_unittests.cc.

                                               {
  Canvas canvas;
  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);
  Paint paint = {.image_filter =
                     ImageFilter::MakeBlur(Sigma(20.0), Sigma(20.0),
                                           FilterContents::BlurStyle::kNormal,
                                           Entity::TileMode::kDecal)};
  Vector2 clip_size = {150, 75};
  Vector2 center = Vector2(1024, 768) / 2;
  canvas.Scale(GetContentScale());
  canvas.ClipRect(
      Rect::MakeLTRB(center.x, center.y, center.x, center.y).Expand(clip_size));
  canvas.Translate({center.x, center.y, 0});
  canvas.Scale({0.6, 0.6, 1});
 
  canvas.DrawImageRect(std::make_shared<Image>(boston), /*source=*/bounds,
                       /*dest=*/bounds.Shift(-image_center), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [183/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurSetsMipCountOnPass
	)

Definition at line 1044 of file aiks_blur_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
  canvas.SaveLayer({}, std::nullopt,
                   ImageFilter::MakeBlur(Sigma(3), Sigma(3),
                                         FilterContents::BlurStyle::kNormal,
                                         Entity::TileMode::kClamp));
  canvas.Restore();
 
  Picture picture = canvas.EndRecordingAsPicture();
  EXPECT_EQ(4, picture.pass->GetRequiredMipCount());
}

◆ TEST_P() [184/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurSolidColorTinyMipMap
	)

Definition at line 710 of file aiks_blur_unittests.cc.

                                                   {
  for (int32_t i = 1; i < 5; ++i) {
    Canvas canvas;
    Scalar fi = i;
    canvas.DrawPath(
        PathBuilder{}
            .MoveTo({100, 100})
            .LineTo({100.f + fi, 100.f + fi})
            .TakePath(),
        {.color = Color::Chartreuse(),
         .image_filter = ImageFilter::MakeBlur(
             Sigma(0.1), Sigma(0.1), FilterContents::BlurStyle::kNormal,
             Entity::TileMode::kClamp)});
 
    Picture picture = canvas.EndRecordingAsPicture();
    std::shared_ptr<RenderTargetCache> cache =
        std::make_shared<RenderTargetCache>(
            GetContext()->GetResourceAllocator());
    AiksContext aiks_context(GetContext(), nullptr, cache);
    std::shared_ptr<Image> image = picture.ToImage(aiks_context, {1024, 768});
    EXPECT_TRUE(image) << " length " << i;
  }
}

◆ TEST_P() [185/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleInner
	)

Definition at line 906 of file aiks_blur_unittests.cc.

                                         {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  Paint paint;
  paint.color = Color::Green();
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kInner,
      .sigma = Sigma(30),
  };
  canvas.DrawPath(PathBuilder()
                      .MoveTo({200, 200})
                      .LineTo({300, 400})
                      .LineTo({100, 400})
                      .Close()
                      .TakePath(),
                  paint);
 
  // Draw another thing to make sure the clip area is reset.
  Paint red;
  red.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [186/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleInnerGradient
	)

Definition at line 807 of file aiks_blur_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.7568, 0.2627, 0.2118, 1.0}};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  Paint paint;
  paint.color_source = ColorSource::MakeLinearGradient(
      {0, 0}, {200, 200}, std::move(colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kInner,
      .sigma = Sigma(30),
  };
  canvas.DrawPath(PathBuilder()
                      .MoveTo({200, 200})
                      .LineTo({300, 400})
                      .LineTo({100, 400})
                      .Close()
                      .TakePath(),
                  paint);
 
  // Draw another thing to make sure the clip area is reset.
  Paint red;
  red.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [187/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleOuter
	)

Definition at line 934 of file aiks_blur_unittests.cc.

                                         {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  Paint paint;
  paint.color = Color::Green();
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kOuter,
      .sigma = Sigma(30),
  };
  canvas.DrawPath(PathBuilder()
                      .MoveTo({200, 200})
                      .LineTo({300, 400})
                      .LineTo({100, 400})
                      .Close()
                      .TakePath(),
                  paint);
 
  // Draw another thing to make sure the clip area is reset.
  Paint red;
  red.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [188/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleOuterGradient
	)

Definition at line 873 of file aiks_blur_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.7568, 0.2627, 0.2118, 1.0}};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  Paint paint;
  paint.color_source = ColorSource::MakeLinearGradient(
      {0, 0}, {200, 200}, std::move(colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kOuter,
      .sigma = Sigma(30),
  };
  canvas.DrawPath(PathBuilder()
                      .MoveTo({200, 200})
                      .LineTo({300, 400})
                      .LineTo({100, 400})
                      .Close()
                      .TakePath(),
                  paint);
 
  // Draw another thing to make sure the clip area is reset.
  Paint red;
  red.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [189/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleSolid
	)

Definition at line 962 of file aiks_blur_unittests.cc.

                                         {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  Paint paint;
  paint.color = Color::Green();
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kSolid,
      .sigma = Sigma(30),
  };
  canvas.DrawPath(PathBuilder()
                      .MoveTo({200, 200})
                      .LineTo({300, 400})
                      .LineTo({100, 400})
                      .Close()
                      .TakePath(),
                  paint);
 
  // Draw another thing to make sure the clip area is reset.
  Paint red;
  red.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [190/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleSolidGradient
	)

Definition at line 840 of file aiks_blur_unittests.cc.

                                                 {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.7568, 0.2627, 0.2118, 1.0}};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  Paint paint;
  paint.color_source = ColorSource::MakeLinearGradient(
      {0, 0}, {200, 200}, std::move(colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kSolid,
      .sigma = Sigma(30),
  };
  canvas.DrawPath(PathBuilder()
                      .MoveTo({200, 200})
                      .LineTo({300, 400})
                      .LineTo({100, 400})
                      .Close()
                      .TakePath(),
                  paint);
 
  // Draw another thing to make sure the clip area is reset.
  Paint red;
  red.color = Color::Red();
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [191/450]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurWithoutDecalSupport
	)

Definition at line 503 of file aiks_blur_unittests.cc.

                                                  {
  if (GetParam() != PlaygroundBackend::kMetal) {
    GTEST_SKIP_(
        "This backend doesn't yet support setting device capabilities.");
  }
  if (!WillRenderSomething()) {
    // Sometimes these tests are run without playgrounds enabled which is
    // pointless for this test since we are asserting that
    // `SupportsDecalSamplerAddressMode` is called.
    GTEST_SKIP_("This test requires playgrounds.");
  }
 
  std::shared_ptr<const Capabilities> old_capabilities =
      GetContext()->GetCapabilities();
  auto mock_capabilities = std::make_shared<MockCapabilities>();
  EXPECT_CALL(*mock_capabilities, SupportsDecalSamplerAddressMode())
      .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, SupportsFramebufferFetch);
  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);
  ASSERT_TRUE(SetCapabilities(mock_capabilities).ok());
 
  auto texture = std::make_shared<Image>(CreateTextureForFixture("boston.jpg"));
  Canvas canvas;
  canvas.Scale(GetContentScale() * 0.5);
  canvas.DrawPaint({.color = Color::Black()});
  canvas.DrawImage(
      texture, Point(200, 200),
      {
          .image_filter = ImageFilter::MakeBlur(
              Sigma(20.0), Sigma(20.0), FilterContents::BlurStyle::kNormal,
              Entity::TileMode::kDecal),
      });
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [192/450]

impeller::testing::TEST_P	(	AiksTest	,
		GradientStrokesRenderCorrectly
	)

Definition at line 624 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 (AiksTest::ImGuiBegin("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));
 
    SkPath path;
    path.moveTo(20, 20);
    path.quadTo({60, 20}, {60, 60});
    path.close();
    path.moveTo(60, 20);
    path.quadTo({60, 60}, {20, 60});
 
    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);
 
      SkMatrix screen_to_canvas;
      if (!builder.GetTransform().invert(&screen_to_canvas)) {
        return nullptr;
      }
      Matrix ip_matrix = ToMatrix(screen_to_canvas);
      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);
      SkPath circle;
      circle.addCircle(middle.x, middle.y, radius);
      builder.ClipPath(circle);
    }
 
    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));
}

◆ TEST_P() [193/450]

impeller::testing::TEST_P	(	AiksTest	,
		GuassianBlurUpdatesMipmapContents
	)

Definition at line 1016 of file aiks_blur_unittests.cc.

                                                    {
  // This makes sure if mip maps are recycled across invocations of blurs the
  // contents get updated each frame correctly. If they aren't updated the color
  // inside the blur and outside the blur will be different.
  //
  // If there is some change to render target caching this could display a false
  // positive in the future.  Also, if the LOD that is rendered is 1 it could
  // present a false positive.
  int32_t count = 0;
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    Canvas canvas;
    if (count++ == 0) {
      canvas.DrawCircle({100, 100}, 50, {.color = Color::CornflowerBlue()});
    } else {
      canvas.DrawCircle({100, 100}, 50, {.color = Color::Chartreuse()});
    }
    canvas.ClipRRect(Rect::MakeLTRB(75, 50, 375, 275), {20, 20});
    canvas.SaveLayer({.blend_mode = BlendMode::kSource}, std::nullopt,
                     ImageFilter::MakeBlur(Sigma(30.0), Sigma(30.0),
                                           FilterContents::BlurStyle::kNormal,
                                           Entity::TileMode::kClamp));
    canvas.Restore();
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [194/450]

impeller::testing::TEST_P	(	AiksTest	,
		ImageColorSourceEffectTransform
	)

Definition at line 2573 of file aiks_unittests.cc.

                                                  {
  // Compare with https://fiddle.skia.org/c/6cdc5aefb291fda3833b806ca347a885
 
  Canvas canvas;
  auto texture = CreateTextureForFixture("monkey.png");
 
  canvas.DrawPaint({.color = Color::White()});
 
  // Translation
  {
    Paint paint;
    paint.color_source = ColorSource::MakeImage(
        texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
        Matrix::MakeTranslation({50, 50}));
    canvas.DrawRect(Rect::MakeLTRB(0, 0, 100, 100), paint);
  }
 
  // Rotation/skew
  {
    canvas.Save();
    canvas.Rotate(Degrees(45));
    Paint paint;
    paint.color_source = ColorSource::MakeImage(
        texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
        Matrix(1, -1, 0, 0,  //
               1, 1, 0, 0,   //
               0, 0, 1, 0,   //
               0, 0, 0, 1)   //
    );
    canvas.DrawRect(Rect::MakeLTRB(100, 0, 200, 100), paint);
    canvas.Restore();
  }
 
  // Scale
  {
    canvas.Translate(Vector2(100, 0));
    canvas.Scale(Vector2(100, 100));
    Paint paint;
    paint.color_source = ColorSource::MakeImage(
        texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
        Matrix::MakeScale(Vector2(0.005, 0.005)));
    canvas.DrawRect(Rect::MakeLTRB(0, 0, 1, 1), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [195/450]

impeller::testing::TEST_P	(	AiksTest	,
		ImageFilteredSaveLayerWithUnboundedContents
	)

Definition at line 1872 of file aiks_unittests.cc.

                                                              {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  auto test = [&canvas](const std::shared_ptr<ImageFilter>& filter) {
    auto DrawLine = [&canvas](const Point& p0, const Point& p1,
                              const Paint& p) {
      auto path = PathBuilder{}
                      .AddLine(p0, p1)
                      .SetConvexity(Convexity::kConvex)
                      .TakePath();
      Paint paint = p;
      paint.style = Paint::Style::kStroke;
      canvas.DrawPath(path, paint);
    };
    // Registration marks for the edge of the SaveLayer
    DrawLine(Point(75, 100), Point(225, 100), {.color = Color::White()});
    DrawLine(Point(75, 200), Point(225, 200), {.color = Color::White()});
    DrawLine(Point(100, 75), Point(100, 225), {.color = Color::White()});
    DrawLine(Point(200, 75), Point(200, 225), {.color = Color::White()});
 
    canvas.SaveLayer({.image_filter = filter},
                     Rect::MakeLTRB(100, 100, 200, 200));
    {
      // DrawPaint to verify correct behavior when the contents are unbounded.
      canvas.DrawPaint({.color = Color::Yellow()});
 
      // Contrasting rectangle to see interior blurring
      canvas.DrawRect(Rect::MakeLTRB(125, 125, 175, 175),
                      {.color = Color::Blue()});
    }
    canvas.Restore();
  };
 
  test(ImageFilter::MakeBlur(Sigma{10.0}, Sigma{10.0},
                             FilterContents::BlurStyle::kNormal,
                             Entity::TileMode::kDecal));
 
  canvas.Translate({200.0, 0.0});
 
  test(ImageFilter::MakeDilate(Radius{10.0}, Radius{10.0}));
 
  canvas.Translate({200.0, 0.0});
 
  test(ImageFilter::MakeErode(Radius{10.0}, Radius{10.0}));
 
  canvas.Translate({-400.0, 200.0});
 
  auto rotate_filter =
      ImageFilter::MakeMatrix(Matrix::MakeTranslation({150, 150}) *
                                  Matrix::MakeRotationZ(Degrees{10.0}) *
                                  Matrix::MakeTranslation({-150, -150}),
                              SamplerDescriptor{});
  test(rotate_filter);
 
  canvas.Translate({200.0, 0.0});
 
  auto rgb_swap_filter = ImageFilter::MakeFromColorFilter(
      *ColorFilter::MakeMatrix({.array = {
                                    0, 1, 0, 0, 0,  //
                                    0, 0, 1, 0, 0,  //
                                    1, 0, 0, 0, 0,  //
                                    0, 0, 0, 1, 0   //
                                }}));
  test(rgb_swap_filter);
 
  canvas.Translate({200.0, 0.0});
 
  test(ImageFilter::MakeCompose(*rotate_filter, *rgb_swap_filter));
 
  canvas.Translate({-400.0, 200.0});
 
  test(ImageFilter::MakeLocalMatrix(Matrix::MakeTranslation({25.0, 25.0}),
                                    *rotate_filter));
 
  canvas.Translate({200.0, 0.0});
 
  test(ImageFilter::MakeLocalMatrix(Matrix::MakeTranslation({25.0, 25.0}),
                                    *rgb_swap_filter));
 
  canvas.Translate({200.0, 0.0});
 
  test(ImageFilter::MakeLocalMatrix(
      Matrix::MakeTranslation({25.0, 25.0}),
      *ImageFilter::MakeCompose(*rotate_filter, *rgb_swap_filter)));
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [196/450]

impeller::testing::TEST_P	(	AiksTest	,
		ImageFilteredUnboundedSaveLayerWithUnboundedContents
	)

Definition at line 1961 of file aiks_unittests.cc.

                                                                       {
  Canvas canvas;
  canvas.Scale(GetContentScale());
 
  auto blur_filter = ImageFilter::MakeBlur(Sigma{10.0}, Sigma{10.0},
                                           FilterContents::BlurStyle::kNormal,
                                           Entity::TileMode::kDecal);
 
  canvas.SaveLayer({.image_filter = blur_filter}, std::nullopt);
  {
    // DrawPaint to verify correct behavior when the contents are unbounded.
    canvas.DrawPaint({.color = Color::Yellow()});
 
    // Contrasting rectangle to see interior blurring
    canvas.DrawRect(Rect::MakeLTRB(125, 125, 175, 175),
                    {.color = Color::Blue()});
  }
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [197/450]

impeller::testing::TEST_P	(	AiksTest	,
		LinearToSrgbFilterSubpassCollapseOptimization
	)

Definition at line 1782 of file aiks_unittests.cc.

                                                                {
  Canvas canvas;
 
  canvas.SaveLayer({
      .color_filter = ColorFilter::MakeLinearToSrgb(),
  });
 
  canvas.Translate({500, 300, 0});
  canvas.Rotate(Radians(2 * kPi / 3));
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [198/450]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurDoesntStretchContents
	)

Definition at line 1198 of file aiks_blur_unittests.cc.

                                                {
  Scalar sigma = 70;
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    if (AiksTest::ImGuiBegin("Controls", nullptr,
                             ImGuiWindowFlags_AlwaysAutoResize)) {
      ImGui::SliderFloat("Sigma", &sigma, 0, 500);
      ImGui::End();
    }
    Canvas canvas;
    canvas.Scale(GetContentScale());
    canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
    std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
    ColorSource image_source = ColorSource::MakeImage(
        boston, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {}, {});
 
    canvas.Transform(Matrix::MakeTranslation({100, 100, 0}) *
                     Matrix::MakeScale({0.5, 0.5, 1.0}));
    Paint paint = {
        .color_source = image_source,
        .mask_blur_descriptor =
            Paint::MaskBlurDescriptor{
                .style = FilterContents::BlurStyle::kNormal,
                .sigma = Sigma(sigma),
            },
    };
    canvas.DrawRect(
        Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height),
        paint);
 
    return canvas.EndRecordingAsPicture();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [199/450]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurTexture
	)

Definition at line 990 of file aiks_blur_unittests.cc.

                                  {
  Scalar sigma = 30;
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    if (AiksTest::ImGuiBegin("Controls", nullptr,
                             ImGuiWindowFlags_AlwaysAutoResize)) {
      ImGui::SliderFloat("Sigma", &sigma, 0, 500);
      ImGui::End();
    }
    Canvas canvas;
    canvas.Scale(GetContentScale());
    Paint paint;
    paint.color = Color::Green();
    paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
        .style = FilterContents::BlurStyle::kNormal,
        .sigma = Sigma(sigma),
    };
    std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
    canvas.DrawImage(std::make_shared<Image>(boston), {200, 200}, paint);
    Paint red;
    red.color = Color::Red();
    canvas.DrawRect(Rect::MakeXYWH(0, 0, 200, 200), red);
    return canvas.EndRecordingAsPicture();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [200/450]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurWithZeroSigmaIsSkipped
	)

Definition at line 277 of file aiks_blur_unittests.cc.

                                                 {
  Canvas canvas;
 
  Paint paint = {
      .color = Color::Blue(),
      .mask_blur_descriptor =
          Paint::MaskBlurDescriptor{
              .style = FilterContents::BlurStyle::kNormal,
              .sigma = Sigma(0),
          },
  };
 
  canvas.DrawCircle({300, 300}, 200, paint);
  canvas.DrawRect(Rect::MakeLTRB(100, 300, 500, 600), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [201/450]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixBackdropFilter
	)

Definition at line 2328 of file aiks_unittests.cc.

                                       {
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Black()});
  canvas.SaveLayer({}, std::nullopt);
  {
    canvas.DrawCircle(Point(200, 200), 100,
                      {.color = Color::Green().WithAlpha(0.5),
                       .blend_mode = BlendMode::kPlus});
    // Should render a second circle, centered on the bottom-right-most edge of
    // the circle.
    canvas.SaveLayer(
        {}, std::nullopt,
        ImageFilter::MakeMatrix(
            Matrix::MakeTranslation(Vector2(1, 1) * (100 + 100 * k1OverSqrt2)) *
                Matrix::MakeScale(Vector2(1, 1) * 0.5) *
                Matrix::MakeTranslation(Vector2(-100, -100)),
            SamplerDescriptor{}));
    canvas.Restore();
  }
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [202/450]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen
	)

Definition at line 2492 of file aiks_unittests.cc.

                                                                        {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.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.
  canvas.SaveLayer({
      .image_filter = std::make_shared<MatrixImageFilter>(
          Matrix::MakeTranslation({300, 0}) * Matrix::MakeScale({2, 2, 2}),
          SamplerDescriptor{}),
  });
  canvas.DrawCircle({-150, 0}, 50, {.color = Color::Green()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [203/450]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen
	)

Definition at line 2475 of file aiks_unittests.cc.

                                                                         {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.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.
  canvas.SaveLayer({
      .image_filter = std::make_shared<MatrixImageFilter>(
          Matrix::MakeTranslation({300, 0}), SamplerDescriptor{}),
  });
  canvas.DrawCircle({-300, 0}, 100, {.color = Color::Green()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [204/450]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterMagnify
	)

Definition at line 2448 of file aiks_unittests.cc.

                                           {
  Scalar scale = 2.0;
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    if (AiksTest::ImGuiBegin("Controls", nullptr,
                             ImGuiWindowFlags_AlwaysAutoResize)) {
      ImGui::SliderFloat("Scale", &scale, 1, 2);
      ImGui::End();
    }
    Canvas canvas;
    canvas.Scale(GetContentScale());
    auto image =
        std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
    canvas.Translate({600, -200});
    canvas.SaveLayer({
        .image_filter = std::make_shared<MatrixImageFilter>(
            Matrix::MakeScale({scale, scale, 1}), SamplerDescriptor{}),
    });
    canvas.DrawImage(image, {0, 0},
                     Paint{.color = Color::White().WithAlpha(0.5)});
    canvas.Restore();
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [205/450]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixSaveLayerFilter
	)

Definition at line 2301 of file aiks_unittests.cc.

                                        {
  Canvas canvas;
  canvas.DrawPaint({.color = Color::Black()});
  canvas.SaveLayer({}, std::nullopt);
  {
    canvas.DrawCircle(Point(200, 200), 100,
                      {.color = Color::Green().WithAlpha(0.5),
                       .blend_mode = BlendMode::kPlus});
    // Should render a second circle, centered on the bottom-right-most edge of
    // the circle.
    canvas.SaveLayer({.image_filter = ImageFilter::MakeMatrix(
                          Matrix::MakeTranslation(Vector2(1, 1) *
                                                  (200 + 100 * k1OverSqrt2)) *
                              Matrix::MakeScale(Vector2(1, 1) * 0.5) *
                              Matrix::MakeTranslation(Vector2(-200, -200)),
                          SamplerDescriptor{})},
                     std::nullopt);
    canvas.DrawCircle(Point(200, 200), 100,
                      {.color = Color::Green().WithAlpha(0.5),
                       .blend_mode = BlendMode::kPlus});
    canvas.Restore();
  }
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [206/450]

impeller::testing::TEST_P	(	AiksTest	,
		MipmapGenerationWorksCorrectly
	)

Definition at line 2747 of file aiks_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(GetContext()->GetResourceAllocator()));
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({command_buffer}).ok());
 
  auto image = std::make_shared<Image>(texture);
 
  Canvas canvas;
  canvas.DrawImageRect(image, Rect::MakeSize(texture->GetSize()),
                       Rect::MakeLTRB(0, 0, 100, 100), {});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [207/450]

impeller::testing::TEST_P	(	AiksTest	,
		OpaqueEntitiesGetCoercedToSource
	)

Definition at line 2099 of file aiks_unittests.cc.

                                                   {
  Canvas canvas;
  canvas.Scale(Vector2(1.618, 1.618));
  canvas.DrawCircle(Point(), 10,
                    {
                        .color = Color::CornflowerBlue(),
                        .blend_mode = BlendMode::kSourceOver,
                    });
  Picture picture = canvas.EndRecordingAsPicture();
 
  // Extract the SolidColorSource.
  // Entity entity;
  std::vector<Entity> entity;
  std::shared_ptr<SolidColorContents> contents;
  picture.pass->IterateAllEntities([e = &entity, &contents](Entity& entity) {
    if (ScalarNearlyEqual(entity.GetTransform().GetScale().x, 1.618f)) {
      contents =
          std::static_pointer_cast<SolidColorContents>(entity.GetContents());
      e->emplace_back(entity.Clone());
      return false;
    }
    return true;
  });
 
  ASSERT_TRUE(entity.size() >= 1);
  ASSERT_TRUE(contents->IsOpaque());
  ASSERT_EQ(entity[0].GetBlendMode(), BlendMode::kSource);
}

◆ TEST_P() [208/450]

impeller::testing::TEST_P	(	AiksTest	,
		PaintBlendModeIsRespected
	)

Definition at line 114 of file aiks_blend_unittests.cc.

                                            {
  Paint paint;
  Canvas canvas;
  // Default is kSourceOver.
  paint.color = Color(1, 0, 0, 0.5);
  canvas.DrawCircle(Point(150, 200), 100, paint);
  paint.color = Color(0, 1, 0, 0.5);
  canvas.DrawCircle(Point(250, 200), 100, paint);
 
  paint.blend_mode = BlendMode::kPlus;
  paint.color = Color::Red();
  canvas.DrawCircle(Point(450, 250), 100, paint);
  paint.color = Color::Green();
  canvas.DrawCircle(Point(550, 250), 100, paint);
  paint.color = Color::Blue();
  canvas.DrawCircle(Point(500, 150), 100, paint);
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [209/450]

impeller::testing::TEST_P	(	AiksTest	,
		PaintWithFilters
	)

Definition at line 1529 of file aiks_unittests.cc.

                                   {
  // validate that a paint with a color filter "HasFilters", no other filters
  // impact this setting.
  Paint paint;
 
  ASSERT_FALSE(paint.HasColorFilter());
 
  paint.color_filter =
      ColorFilter::MakeBlend(BlendMode::kSourceOver, Color::Blue());
 
  ASSERT_TRUE(paint.HasColorFilter());
 
  paint.image_filter = ImageFilter::MakeBlur(Sigma(1.0), Sigma(1.0),
                                             FilterContents::BlurStyle::kNormal,
                                             Entity::TileMode::kClamp);
 
  ASSERT_TRUE(paint.HasColorFilter());
 
  paint.mask_blur_descriptor = {};
 
  ASSERT_TRUE(paint.HasColorFilter());
 
  paint.color_filter = nullptr;
 
  ASSERT_FALSE(paint.HasColorFilter());
}

◆ TEST_P() [210/450]

impeller::testing::TEST_P	(	AiksTest	,
		ParentSaveLayerCreatesRenderPassWhenChildBackdropFilterIsPresent
	)

Definition at line 1580 of file aiks_unittests.cc.

                                                                         {
  Canvas canvas;
  canvas.SaveLayer({}, std::nullopt, ImageFilter::MakeMatrix(Matrix(), {}));
  canvas.DrawPaint({.color = Color::Red(), .blend_mode = BlendMode::kSource});
  canvas.DrawPaint({.color = Color::CornflowerBlue().WithAlpha(0.75),
                    .blend_mode = BlendMode::kSourceOver});
  canvas.Restore();
 
  Picture picture = canvas.EndRecordingAsPicture();
 
  std::shared_ptr<ContextSpy> spy = ContextSpy::Make();
  std::shared_ptr<Context> real_context = GetContext();
  std::shared_ptr<ContextMock> mock_context = spy->MakeContext(real_context);
  AiksContext renderer(mock_context, nullptr);
  std::shared_ptr<Image> image = picture.ToImage(renderer, {300, 300});
 
  ASSERT_EQ(spy->render_passes_.size(),
            GetBackend() == PlaygroundBackend::kOpenGLES ? 4llu : 3llu);
  std::shared_ptr<RenderPass> render_pass = spy->render_passes_[0];
  ASSERT_EQ(render_pass->GetCommands().size(), 0llu);
}

◆ TEST_P() [211/450]

impeller::testing::TEST_P	(	AiksTest	,
		PipelineBlendSingleParameter
	)

Definition at line 2392 of file aiks_unittests.cc.

                                               {
  Canvas canvas;
 
  // Should render a green square in the middle of a blue circle.
  canvas.SaveLayer({});
  {
    canvas.Translate(Point(100, 100));
    canvas.DrawCircle(Point(200, 200), 200, {.color = Color::Blue()});
    canvas.ClipRect(Rect::MakeXYWH(100, 100, 200, 200));
    canvas.DrawCircle(Point(200, 200), 200,
                      {
                          .color = Color::Green(),
                          .blend_mode = BlendMode::kSourceOver,
                          .image_filter = ImageFilter::MakeFromColorFilter(
                              *ColorFilter::MakeBlend(BlendMode::kDestination,
                                                      Color::White())),
                      });
    canvas.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [212/450]

impeller::testing::TEST_P	(	AiksTest	,
		ReleasesTextureOnTeardown
	)

Definition at line 2416 of file aiks_unittests.cc.

                                            {
  auto context = MakeContext();
  std::weak_ptr<Texture> weak_texture;
 
  {
    auto texture = CreateTextureForFixture("table_mountain_nx.png");
 
    Canvas canvas;
    canvas.Scale(GetContentScale());
    canvas.Translate({100.0f, 100.0f, 0});
 
    Paint paint;
    paint.color_source = ColorSource::MakeImage(
        texture, Entity::TileMode::kClamp, Entity::TileMode::kClamp, {}, {});
    canvas.DrawRect(Rect::MakeXYWH(0, 0, 600, 600), paint);
 
    ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
  }
 
  // 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.";
}

◆ TEST_P() [213/450]

impeller::testing::TEST_P	(	AiksTest	,
		RotateColorFilteredPath
	)

Definition at line 19 of file aiks_dl_path_unittests.cc.

                                          {
  DisplayListBuilder builder;
  builder.Transform(SkMatrix::Translate(300, 300) * SkMatrix::RotateDeg(90));
 
  SkPath arrow_stem;
  SkPath arrow_head;
 
  arrow_stem.moveTo({120, 190}).lineTo({120, 50});
  arrow_head.moveTo({50, 120}).lineTo({120, 190}).lineTo({190, 120});
 
  auto filter =
      DlBlendColorFilter::Make(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, paint);
  builder.DrawPath(arrow_head, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [214/450]

impeller::testing::TEST_P	(	AiksTest	,
		SaveLayerDrawsBehindSubsequentEntities
	)

Definition at line 1377 of file aiks_unittests.cc.

                                                         {
  // Compare with https://fiddle.skia.org/c/9e03de8567ffb49e7e83f53b64bcf636
  Canvas canvas;
  Paint paint;
 
  paint.color = Color::Black();
  Rect rect = Rect::MakeXYWH(25, 25, 25, 25);
  canvas.DrawRect(rect, paint);
 
  canvas.Translate({10, 10});
  canvas.SaveLayer({});
 
  paint.color = Color::Green();
  canvas.DrawRect(rect, paint);
 
  canvas.Restore();
 
  canvas.Translate({10, 10});
  paint.color = Color::Red();
  canvas.DrawRect(rect, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [215/450]

impeller::testing::TEST_P	(	AiksTest	,
		SaveLayerFiltersScaleWithTransform
	)

Definition at line 1458 of file aiks_unittests.cc.

                                                     {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.Translate(Vector2(100, 100));
 
  auto texture = std::make_shared<Image>(CreateTextureForFixture("boston.jpg"));
  auto draw_image_layer = [&canvas, &texture](const Paint& paint) {
    canvas.SaveLayer(paint);
    canvas.DrawImage(texture, {}, Paint{});
    canvas.Restore();
  };
 
  Paint effect_paint;
  effect_paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kNormal,
      .sigma = Sigma{6},
  };
  draw_image_layer(effect_paint);
 
  canvas.Translate(Vector2(300, 300));
  canvas.Scale(Vector2(3, 3));
  draw_image_layer(effect_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [216/450]

impeller::testing::TEST_P	(	AiksTest	,
		SetContentsWithRegion
	)

Definition at line 2840 of file aiks_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()->GetResourceAllocator()) &&
      GetContext()->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok();
  ASSERT_TRUE(did_submit);
 
  auto image = std::make_shared<Image>(bridge);
 
  Canvas canvas;
  canvas.DrawImage(image, {0, 0}, {});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [217/450]

impeller::testing::TEST_P	(	AiksTest	,
		SiblingSaveLayerBoundsAreRespected
	)

Definition at line 1401 of file aiks_unittests.cc.

                                                     {
  Canvas canvas;
  Paint paint;
  Rect rect = Rect::MakeXYWH(0, 0, 1000, 1000);
 
  // Black, green, and red squares offset by [10, 10].
  {
    canvas.SaveLayer({}, Rect::MakeXYWH(25, 25, 25, 25));
    paint.color = Color::Black();
    canvas.DrawRect(rect, paint);
    canvas.Restore();
  }
 
  {
    canvas.SaveLayer({}, Rect::MakeXYWH(35, 35, 25, 25));
    paint.color = Color::Green();
    canvas.DrawRect(rect, paint);
    canvas.Restore();
  }
 
  {
    canvas.SaveLayer({}, Rect::MakeXYWH(45, 45, 25, 25));
    paint.color = Color::Red();
    canvas.DrawRect(rect, paint);
    canvas.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [218/450]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorApplyColorFilter
	)

Definition at line 2352 of file aiks_unittests.cc.

                                             {
  auto contents = SolidColorContents();
  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));
}

◆ TEST_P() [219/450]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorCirclesOvalsRRectsMaskBlurCorrectly
	)

Definition at line 1188 of file aiks_unittests.cc.

                                                                {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  paint.mask_blur_descriptor = Paint::MaskBlurDescriptor{
      .style = FilterContents::BlurStyle::kNormal,
      .sigma = Sigma{1},
  };
 
  canvas.DrawPaint({.color = Color::White()});
 
  paint.color = Color::Crimson();
  Scalar y = 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 10.0f;
    canvas.DrawRect(Rect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                   radius, 60.0f - radius),
                    paint);
  }
 
  paint.color = Color::Blue();
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 10.0f;
    canvas.DrawCircle({x + 25, y + 25}, radius, paint);
  }
 
  paint.color = Color::Green();
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 10.0f;
    canvas.DrawOval(Rect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                   radius, 60.0f - radius),
                    paint);
  }
 
  paint.color = Color::Purple();
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 20.0f;
    canvas.DrawRRect(Rect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                     {radius, radius},                    //
                     paint);
  }
 
  paint.color = Color::Orange();
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 20.0f;
    canvas.DrawRRect(Rect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                     {radius, 5.0f}, paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [220/450]

impeller::testing::TEST_P	(	AiksTest	,
		SolidStrokesRenderCorrectly
	)

Definition at line 187 of file aiks_path_unittests.cc.

                                              {
  // Compare with https://fiddle.skia.org/c/027392122bec8ac2b5d5de00a4b9bbe2
  auto callback = [&](AiksContext& renderer) -> std::optional<Picture> {
    static Color color = Color::Black().WithAlpha(0.5);
    static float scale = 3;
    static bool add_circle_clip = true;
 
    if (AiksTest::ImGuiBegin("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();
    }
 
    Canvas canvas;
    canvas.Scale(GetContentScale());
    Paint paint;
 
    paint.color = Color::White();
    canvas.DrawPaint(paint);
 
    paint.color = color;
    paint.style = Paint::Style::kStroke;
    paint.stroke_width = 10;
 
    Path path = PathBuilder{}
                    .MoveTo({20, 20})
                    .QuadraticCurveTo({60, 20}, {60, 60})
                    .Close()
                    .MoveTo({60, 20})
                    .QuadraticCurveTo({60, 60}, {20, 60})
                    .TakePath();
 
    canvas.Scale(Vector2(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);
 
      auto screen_to_canvas = canvas.GetCurrentTransform().Invert();
      Point point_a = screen_to_canvas * handle_a * GetContentScale();
      Point point_b = screen_to_canvas * handle_b * GetContentScale();
 
      Point middle = (point_a + point_b) / 2;
      auto radius = point_a.GetDistance(middle);
      canvas.ClipPath(PathBuilder{}.AddCircle(middle, radius).TakePath());
    }
 
    for (auto join : {Join::kBevel, Join::kRound, Join::kMiter}) {
      paint.stroke_join = join;
      for (auto cap : {Cap::kButt, Cap::kSquare, Cap::kRound}) {
        paint.stroke_cap = cap;
        canvas.DrawPath(path, paint);
        canvas.Translate({80, 0});
      }
      canvas.Translate({-240, 60});
    }
 
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [221/450]

impeller::testing::TEST_P	(	AiksTest	,
		SrgbToLinearFilterSubpassCollapseOptimization
	)

Definition at line 1796 of file aiks_unittests.cc.

                                                                {
  Canvas canvas;
 
  canvas.SaveLayer({
      .color_filter = ColorFilter::MakeSrgbToLinear(),
  });
 
  canvas.Translate({500, 300, 0});
  canvas.Rotate(Radians(2 * kPi / 3));
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 200, 200), {.color = Color::Blue()});
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [222/450]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedCirclesRenderCorrectly
	)

Definition at line 970 of file aiks_unittests.cc.

                                                {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  Paint paint;
  const int color_count = 3;
  Color colors[color_count] = {
      Color::Blue(),
      Color::Green(),
      Color::Crimson(),
  };
 
  paint.color = Color::White();
  canvas.DrawPaint(paint);
 
  int c_index = 0;
 
  auto draw = [&paint, &colors, &c_index](Canvas& canvas, Point center,
                                          Scalar r, Scalar dr, int n) {
    for (int i = 0; i < n; i++) {
      paint.color = colors[(c_index++) % color_count];
      canvas.DrawCircle(center, r, paint);
      r += dr;
    }
  };
 
  paint.style = Paint::Style::kStroke;
  paint.stroke_width = 1;
  draw(canvas, {10, 10}, 2, 2, 14);  // r = [2, 28], covers [1,29]
  paint.stroke_width = 5;
  draw(canvas, {10, 10}, 35, 10, 56);  // r = [35, 585], covers [30,590]
 
  std::vector<Color> gradient_colors = {
      Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0},
      Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0},
      Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0},
      Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0},
      Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0},
      Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0},
      Color{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 = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  paint.color_source = ColorSource::MakeRadialGradient(
      {500, 600}, 75, std::move(gradient_colors), std::move(stops),
      Entity::TileMode::kMirror, {});
  draw(canvas, {500, 600}, 5, 10, 10);
 
  paint.color_source = ColorSource::MakeImage(
      texture, Entity::TileMode::kRepeat, Entity::TileMode::kRepeat, {},
      Matrix::MakeTranslation({700, 200}));
  draw(canvas, {800, 300}, 5, 10, 10);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [223/450]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedPathWithMoveToThenCloseDrawnCorrectly
	)

Definition at line 2800 of file aiks_unittests.cc.

                                                               {
  Path path = PathBuilder{}
                  .MoveTo({0, 400})
                  .LineTo({0, 0})
                  .LineTo({400, 0})
                  // MoveTo implicitly adds a contour, ensure that close doesn't
                  // add another nearly-empty contour.
                  .MoveTo({0, 400})
                  .Close()
                  .TakePath();
 
  Canvas canvas;
  canvas.Translate({50, 50, 0});
  canvas.DrawPath(path, {
                            .color = Color::Blue(),
                            .stroke_width = 10,
                            .stroke_cap = Cap::kRound,
                            .style = Paint::Style::kStroke,
                        });
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [224/450]

impeller::testing::TEST_P	(	AiksTest	,
		SubpassWithClearColorOptimization
	)

Definition at line 2551 of file aiks_unittests.cc.

                                                    {
  Canvas canvas;
 
  // Use a non-srcOver blend mode to ensure that we don't detect this as an
  // opacity peephole optimization.
  canvas.SaveLayer(
      {.color = Color::Blue().WithAlpha(0.5), .blend_mode = BlendMode::kSource},
      Rect::MakeLTRB(0, 0, 200, 200));
  canvas.DrawPaint(
      {.color = Color::BlackTransparent(), .blend_mode = BlendMode::kSource});
  canvas.Restore();
 
  canvas.SaveLayer(
      {.color = Color::Blue(), .blend_mode = BlendMode::kDestinationOver});
  canvas.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(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [225/450]

impeller::testing::TEST_P	(	AiksTest	,
		TextForegroundShaderWithTransform
	)

Definition at line 2268 of file aiks_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);
 
  Paint text_paint;
  text_paint.color = Color::Blue();
 
  std::vector<Color> colors = {Color{0.9568, 0.2627, 0.2118, 1.0},
                               Color{0.1294, 0.5882, 0.9529, 1.0}};
  std::vector<Scalar> stops = {
      0.0,
      1.0,
  };
  text_paint.color_source = ColorSource::MakeLinearGradient(
      {0, 0}, {100, 100}, std::move(colors), std::move(stops),
      Entity::TileMode::kRepeat, {});
 
  Canvas canvas;
  canvas.Translate({100, 100});
  canvas.Rotate(Radians(kPi / 4));
 
  auto blob = SkTextBlob::MakeFromString("Hello", sk_font);
  ASSERT_NE(blob, nullptr);
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
  canvas.DrawTextFrame(frame, Point(), text_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [226/450]

impeller::testing::TEST_P	(	AiksTest	,
		TextFrameSubpixelAlignment
	)

Definition at line 672 of file aiks_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 = [&](AiksContext& renderer) -> std::optional<Picture> {
    static float font_size = 20;
    static float phase_variation = 0.2;
    static float speed = 0.5;
    static float magnitude = 100;
    if (AiksTest::ImGuiBegin("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();
    }
 
    Canvas canvas;
    canvas.Scale(GetContentScale());
 
    for (size_t i = 0; i < phase_offsets.size(); i++) {
      auto position =
          Point(200 + magnitude *
                          std::sin((-phase_offsets[i] * k2Pi * phase_variation +
                                    GetSecondsElapsed() * speed)),  //
                200 + i * font_size * 1.1                           //
          );
      if (!RenderTextInCanvasSkia(
              GetContext(), canvas,
              "the quick brown fox jumped over "
              "the lazy dog!.?",
              "Roboto-Regular.ttf",
              {.font_size = font_size, .position = position})) {
        return std::nullopt;
      }
    }
    return canvas.EndRecordingAsPicture();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [227/450]

impeller::testing::TEST_P	(	AiksTest	,
		TextRotated
	)

Definition at line 827 of file aiks_unittests.cc.

                              {
  Canvas canvas;
  canvas.Scale(GetContentScale());
  canvas.DrawPaint({.color = Color(0.1, 0.1, 0.1, 1.0)});
 
  canvas.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(), canvas, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [228/450]

impeller::testing::TEST_P	(	AiksTest	,
		TransformMultipliesCorrectly
	)

Definition at line 872 of file aiks_unittests.cc.

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

◆ TEST_P() [229/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerDrawsCorrectly
	)

Definition at line 1810 of file aiks_unittests.cc.

                                                     {
  Canvas canvas;
 
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
 
  canvas.SaveLayer({.color = Color::Black().WithAlpha(0.5)});
  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [230/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerImageDrawsCorrectly
	)

Definition at line 1983 of file aiks_unittests.cc.

                                                          {
  Canvas canvas;
 
  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
  canvas.DrawImage(image, {100, 100}, {});
 
  canvas.SaveLayer({.color = Color::Black().WithAlpha(0.5)});
  canvas.DrawImage(image, {100, 500}, {});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [231/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly
	)

Definition at line 2067 of file aiks_unittests.cc.

                                                                          {
  Canvas canvas;
  canvas.DrawRect(Rect::MakeXYWH(0, 0, 400, 400), {.color = Color::Red()});
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .blend_mode = BlendMode::kLighten,
  });
  canvas.DrawCircle({200, 200}, 100, {.color = Color::Green()});
  canvas.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [232/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly
	)

Definition at line 1822 of file aiks_unittests.cc.

                                                                         {
  Canvas canvas;
 
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
 
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .color_filter =
          ColorFilter::MakeBlend(BlendMode::kDestinationOver, Color::Red()),
  });
  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [233/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly
	)

Definition at line 1838 of file aiks_unittests.cc.

                                                                         {
  Canvas canvas;
 
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
 
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .image_filter = ImageFilter::MakeFromColorFilter(
          *ColorFilter::MakeBlend(BlendMode::kDestinationOver, Color::Red())),
  });
 
  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [234/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly
	)

Definition at line 1855 of file aiks_unittests.cc.

                                                                            {
  Canvas canvas;
 
  canvas.DrawRect(Rect::MakeXYWH(100, 100, 300, 300), {.color = Color::Blue()});
 
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .color_filter =
          ColorFilter::MakeBlend(BlendMode::kDestinationOver, Color::Red()),
  });
 
  canvas.DrawRect(Rect::MakeXYWH(100, 500, 300, 300), {.color = Color::Blue()});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [235/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorFilterAndImageFilterDrawsCorrectly
	)

Definition at line 2041 of file aiks_unittests.cc.

                                                                        {
  Canvas canvas;
 
  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
  canvas.DrawImage(image, {100, 100}, {});
 
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .image_filter = ImageFilter::MakeFromColorFilter(
          *ColorFilter::MakeMatrix({.array =
                                        {
                                            1, 0,   0, 0,   0,  //
                                            0, 1,   0, 0,   0,  //
                                            0, 0.2, 1, 0,   0,  //
                                            0, 0,   0, 0.5, 0   //
                                        }})),
      .color_filter =
          ColorFilter::MakeBlend(BlendMode::kModulate, Color::Green()),
  });
  canvas.DrawImage(image, {100, 500}, {});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [236/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly
	)

Definition at line 1996 of file aiks_unittests.cc.

                                                                               {
  Canvas canvas;
 
  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
  canvas.DrawImage(image, {100, 100}, {});
 
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .color_filter = ColorFilter::MakeMatrix({.array =
                                                   {
                                                       1, 0, 0, 0, 0,  //
                                                       0, 1, 0, 0, 0,  //
                                                       0, 0, 1, 0, 0,  //
                                                       0, 0, 0, 2, 0   //
                                                   }}),
  });
  canvas.DrawImage(image, {100, 500}, {});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [237/450]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly
	)

Definition at line 2018 of file aiks_unittests.cc.

                                                                               {
  Canvas canvas;
 
  auto image = std::make_shared<Image>(CreateTextureForFixture("airplane.jpg"));
  canvas.DrawImage(image, {100, 100}, {});
 
  canvas.SaveLayer({
      .color = Color::Black().WithAlpha(0.5),
      .image_filter = ImageFilter::MakeFromColorFilter(
          *ColorFilter::MakeMatrix({.array =
                                        {
                                            1, 0, 0, 0, 0,  //
                                            0, 1, 0, 0, 0,  //
                                            0, 0, 1, 0, 0,  //
                                            0, 0, 0, 2, 0   //
                                        }})),
  });
  canvas.DrawImage(image, {100, 500}, {});
  canvas.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
}

◆ TEST_P() [238/450]

impeller::testing::TEST_P	(	AiksTest	,
		VerifyNonOptimizedGradient
	)

Definition at line 807 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(SkRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(0, 0, 300, 300), 4, 4),
                    paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [239/450]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryColorUVPositionData
	)

Definition at line 93 of file aiks_dl_vertices_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->impeller_texture()->GetSize();
 
  paint.setColorSource(std::make_shared<DlImageColorSource>(
      image, DlTileMode::kClamp, DlTileMode::kClamp));
 
  std::vector<SkPoint> positions = {
      SkPoint::Make(0, 0),           SkPoint::Make(size.width, 0),
      SkPoint::Make(0, size.height), SkPoint::Make(size.width, 0),
      SkPoint::Make(0, 0),           SkPoint::Make(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()));
}

◆ TEST_P() [240/450]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryColorUVPositionDataAdvancedBlend
	)

Definition at line 121 of file aiks_dl_vertices_unittests.cc.

                                                                   {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->impeller_texture()->GetSize();
 
  paint.setColorSource(std::make_shared<DlImageColorSource>(
      image, DlTileMode::kClamp, DlTileMode::kClamp));
 
  std::vector<SkPoint> positions = {
      SkPoint::Make(0, 0),           SkPoint::Make(size.width, 0),
      SkPoint::Make(0, size.height), SkPoint::Make(size.width, 0),
      SkPoint::Make(0, 0),           SkPoint::Make(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()));
}

◆ TEST_P() [241/450]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryUVPositionData
	)

Definition at line 47 of file aiks_dl_vertices_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->impeller_texture()->GetSize();
 
  paint.setColorSource(std::make_shared<DlImageColorSource>(
      image, DlTileMode::kClamp, DlTileMode::kClamp));
 
  std::vector<SkPoint> vertex_coordinates = {SkPoint::Make(0, 0),
                                             SkPoint::Make(size.width, 0),
                                             SkPoint::Make(0, size.height)};
  auto vertices = MakeVertices(DlVertexMode::kTriangleStrip, vertex_coordinates,
                               {0, 1, 2}, {}, {});
 
  builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [242/450]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryUVPositionDataWithTranslate
	)

Definition at line 68 of file aiks_dl_vertices_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->impeller_texture()->GetSize();
 
  SkMatrix matrix;
  matrix.setTranslateX(100);
  matrix.setTranslateY(100);
  paint.setColorSource(std::make_shared<DlImageColorSource>(
      image, DlTileMode::kClamp, DlTileMode::kClamp, DlImageSampling::kLinear,
      &matrix));
 
  std::vector<SkPoint> positions = {SkPoint::Make(0, 0),
                                    SkPoint::Make(size.width, 0),
                                    SkPoint::Make(0, size.height)};
  auto vertices =
      MakeVertices(DlVertexMode::kTriangleStrip, positions, {0, 1, 2}, {}, {});
 
  builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [243/450]

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);
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  // Add random byte to get the HostBuffer in a bad alignment.
  uint8_t byte = 0xff;
  BufferView buffer_view =
      renderer->GetTransientsBuffer().Emplace(&byte, /*length=*/1, /*align=*/1);
  EXPECT_EQ(buffer_view.range.offset, 4u);
  EXPECT_EQ(buffer_view.range.length, 1u);
  Entity entity;
 
  std::optional<Entity> result = filter_contents.GetEntity(
      *renderer, entity, /*coverage_hint=*/std::nullopt);
 
  EXPECT_TRUE(result.has_value());
}

◆ TEST_P() [244/450]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitAcrossDifferentPixelFormatsFails
	)

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

◆ TEST_P() [245/450]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitAcrossDifferentSampleCountsFails
	)

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

◆ TEST_P() [246/450]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitPassesForMatchingFormats
	)

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

◆ TEST_P() [247/450]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanBlitSmallRegionToUninitializedTexture
	)

Definition at line 109 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), "", /*slice=*/0));
  EXPECT_TRUE(blit_pass->EncodeCommands(GetContext()->GetResourceAllocator()));
  EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
}

◆ TEST_P() [248/450]

impeller::testing::TEST_P	(	BlitPassTest	,
		ChecksInvalidSliceParameters
	)

Definition at line 81 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, "", /*slice=*/25));
  EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  std::nullopt, "", /*slice=*/6));
  EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                 std::nullopt, "", /*slice=*/0));
}

◆ TEST_P() [249/450]

impeller::testing::TEST_P	(	ComputeTest	,
		1DThreadgroupSizingIsCorrect
	)

Definition at line 175 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(ISize(kCount, 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.range.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();
}

◆ TEST_P() [250/450]

impeller::testing::TEST_P	(	ComputeTest	,
		CanCompute1DimensionalData
	)

Definition at line 373 of file compute_unittests.cc.

                                                {
  using CS = SampleComputeShader;
  auto context = GetContext();
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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(ISize(kCount, 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.range.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();
}

◆ TEST_P() [251/450]

impeller::testing::TEST_P	(	ComputeTest	,
		CanComputePrefixSum
	)

Definition at line 109 of file compute_unittests.cc.

                                         {
  using CS = PrefixSumTestComputeShader;
  auto context = GetContext();
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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));
 
  ASSERT_TRUE(pass->Compute(ISize(kCount, 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.range.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();
}

◆ TEST_P() [252/450]

impeller::testing::TEST_P	(	ComputeTest	,
		CanComputePrefixSumLargeInteractive
	)

Definition at line 228 of file compute_unittests.cc.

                                                         {
  using CS = PrefixSumTestComputeShader;
 
  auto context = GetContext();
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
 
  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));
 
    pass->Compute(ISize(kCount, 1));
    pass->EncodeCommands();
    host_buffer->Reset();
    return context->GetCommandQueue()->Submit({cmd_buffer}).ok();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [253/450]

impeller::testing::TEST_P	(	ComputeTest	,
		CanCreateComputePass
	)

Definition at line 30 of file compute_unittests.cc.

                                          {
  using CS = SampleComputeShader;
  auto context = GetContext();
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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(ISize(kCount, 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.range.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();
}

◆ TEST_P() [254/450]

impeller::testing::TEST_P	(	ComputeTest	,
		CapabilitiesReportSupport
	)

Definition at line 24 of file compute_unittests.cc.

                                               {
  auto context = GetContext();
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
}

◆ TEST_P() [255/450]

impeller::testing::TEST_P	(	ComputeTest	,
		MultiStageInputAndOutput
	)

Definition at line 271 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 = HostBuffer::Create(context->GetResourceAllocator());
  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(ISize(512, 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(ISize(512, 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();
}

◆ TEST_P() [256/450]

impeller::testing::TEST_P	(	ComputeTest	,
		ReturnsEarlyWhenAnyGridDimensionIsZero
	)

Definition at line 452 of file compute_unittests.cc.

                                                            {
  using CS = SampleComputeShader;
  auto context = GetContext();
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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 grid size zero in one dimension. No GPU will
  // tolerate this.
  EXPECT_FALSE(pass->Compute(ISize(0, 1)).ok());
  pass->EncodeCommands();
}

◆ TEST_P() [257/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanBlendDstOverAndDstCorrectly
	)

Definition at line 1238 of file dl_unittests.cc.

                                                        {
  flutter::DisplayListBuilder builder;
 
  {
    builder.SaveLayer(nullptr, nullptr);
    builder.Translate(100, 100);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kRed());
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    builder.Restore();
  }
  {
    builder.SaveLayer(nullptr, nullptr);
    builder.Translate(300, 100);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    paint.setColor(flutter::DlColor::kRed());
    paint.setBlendMode(flutter::DlBlendMode::kDstOver);
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    builder.Restore();
  }
  {
    builder.SaveLayer(nullptr, nullptr);
    builder.Translate(100, 300);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kRed());
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    paint.setBlendMode(flutter::DlBlendMode::kSrc);
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    builder.Restore();
  }
  {
    builder.SaveLayer(nullptr, nullptr);
    builder.Translate(300, 300);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    paint.setColor(flutter::DlColor::kRed());
    paint.setBlendMode(flutter::DlBlendMode::kDst);
    builder.DrawRect(SkRect::MakeSize({200, 200}), paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [258/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanClampTheResultingColorOfColorMatrixFilter
	)

Definition at line 616 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 =
      std::make_shared<flutter::DlMatrixColorFilter>(inner_color_matrix);
  auto outer_color_filter =
      std::make_shared<flutter::DlMatrixColorFilter>(outer_color_matrix);
  auto inner =
      std::make_shared<flutter::DlColorFilterImageFilter>(inner_color_filter);
  auto outer =
      std::make_shared<flutter::DlColorFilterImageFilter>(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), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [259/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawAnOpenPath
	)

Definition at line 406 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)
  SkPath path;
  path.moveTo(50, 50);
  path.lineTo(50, 100);
  path.lineTo(100, 100);
  path.lineTo(100, 50);
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [260/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawArc
	)

Definition at line 152 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;
 
    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 = SkRect::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));
}

◆ TEST_P() [261/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawBackdropFilter
	)

Definition at line 648 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;
 
    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<SkRect> 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 = SkRect::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(SkRect::MakeLTRB(0, 0, 99999, 99999),
                       flutter::DlCanvas::ClipOp::kIntersect, true);
    }
 
    builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(200, 200),
                      flutter::DlImageSampling::kNearestNeighbor, nullptr);
    builder.SaveLayer(bounds.has_value() ? &bounds.value() : nullptr, 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({circle_center.x, circle_center.y}, 100, paint);
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [262/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawCapsAndJoins
	)

Definition at line 106 of file dl_unittests.cc.

                                             {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setStrokeWidth(30);
  paint.setColor(flutter::DlColor::kRed());
 
  auto path =
      SkPathBuilder{}.moveTo(-50, 0).lineTo(0, -50).lineTo(50, 0).snapshot();
 
  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()));
}

◆ TEST_P() [263/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawCorrectlyWithColorFilterAndImageFilter
	)

Definition at line 1289 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 =
      std::make_shared<flutter::DlMatrixColorFilter>(green_color_matrix);
  auto blue_color_filter =
      std::make_shared<flutter::DlMatrixColorFilter>(blue_color_matrix);
  auto blue_image_filter =
      std::make_shared<flutter::DlColorFilterImageFilter>(blue_color_filter);
 
  flutter::DlPaint paint;
  paint.setColor(flutter::DlColor::kRed());
  paint.setColorFilter(green_color_filter);
  paint.setImageFilter(blue_image_filter);
  builder.DrawRect(SkRect::MakeLTRB(100, 100, 500, 500), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [264/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawImage
	)

Definition at line 98 of file dl_unittests.cc.

                                      {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [265/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImage
	)

Definition at line 717 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),
      SkIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      SkRect::MakeLTRB(0, 0, size.width * 2, size.height * 2),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [266/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterBiggerThanDest
	)

Definition at line 763 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),
      SkIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      SkRect::MakeLTRB(0, 0, size.width / 2, size.height / 2),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [267/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterHeightBiggerThanDest
	)

Definition at line 747 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),
      SkIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      SkRect::MakeLTRB(0, 0, size.width, size.height / 2),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [268/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterWidthBiggerThanDest
	)

Definition at line 731 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),
      SkIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      SkRect::MakeLTRB(0, 0, size.width / 2, size.height),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [269/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCornersScaledDown
	)

Definition at line 778 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),
      SkIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      SkRect::MakeLTRB(0, 0, size.width / 4, size.height / 4),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [270/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawPaintWithColorSource
	)

Definition at line 1186 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 = SkRect::MakeWH(300.0, 300.0);
  builder.Save();
  builder.Translate(100, 100);
  builder.ClipRect(clip_bounds, flutter::DlCanvas::ClipOp::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::DlCanvas::ClipOp::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::DlCanvas::ClipOp::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::DlCanvas::ClipOp::kIntersect, false);
  auto texture = CreateTextureForFixture("table_mountain_nx.png");
  auto image = std::make_shared<flutter::DlImageColorSource>(
      DlImageImpeller::Make(texture), flutter::DlTileMode::kRepeat,
      flutter::DlTileMode::kRepeat);
  paint.setColorSource(image);
  builder.DrawPaint(paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [271/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawPoints
	)

Definition at line 805 of file dl_unittests.cc.

                                       {
  flutter::DisplayListBuilder builder;
  SkPoint 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::DlCanvas::PointMode::kPoints, 7, points, paint);
    builder.Translate(150, 0);
    builder.DrawPoints(flutter::DlCanvas::PointMode::kLines, 5, points, paint);
    builder.Translate(150, 0);
    builder.DrawPoints(flutter::DlCanvas::PointMode::kPolygon, 5, points,
                       paint);
    builder.Restore();
    builder.Translate(0, 150);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [272/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawRect
	)

Definition at line 49 of file dl_unittests.cc.

                                     {
  flutter::DisplayListBuilder builder;
  builder.DrawRect(SkRect::MakeXYWH(10, 10, 100, 100),
                   flutter::DlPaint(flutter::DlColor::kBlue()));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [273/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawRectWithLinearToSrgbColorFilter
	)

Definition at line 1170 of file dl_unittests.cc.

                                                                {
  flutter::DlPaint paint;
  paint.setColor(flutter::DlColor(0xFF2196F3).withAlpha(128));
  flutter::DisplayListBuilder builder;
  paint.setColorFilter(
      flutter::DlLinearToSrgbGammaColorFilter::kInstance.get());
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 200, 200), paint);
  builder.Translate(0, 200);
 
  paint.setColorFilter(
      flutter::DlSrgbToLinearGammaColorFilter::kInstance.get());
  builder.DrawRect(SkRect::MakeXYWH(0, 0, 200, 200), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [274/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawShadow
	)

Definition at line 864 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 SkScalar half_spike_rotation = kPi / star_spikes;
  constexpr SkScalar radius = 40;
  constexpr SkScalar spike_size = 10;
  constexpr SkScalar outer_radius = radius + spike_size;
  constexpr SkScalar inner_radius = radius - spike_size;
  std::array<SkPoint, star_spikes * 2> star;
  for (size_t i = 0; i < star_spikes; i++) {
    const SkScalar rotation = half_spike_rotation * i * 2;
    star[i * 2] = SkPoint::Make(50 + std::sin(rotation) * outer_radius,
                                50 - std::cos(rotation) * outer_radius);
    star[i * 2 + 1] = SkPoint::Make(
        50 + std::sin(rotation + half_spike_rotation) * inner_radius,
        50 - std::cos(rotation + half_spike_rotation) * inner_radius);
  }
 
  std::array<SkPath, 4> paths = {
      SkPath{}.addRect(SkRect::MakeXYWH(0, 0, 200, 100)),
      SkPath{}.addRRect(
          SkRRect::MakeRectXY(SkRect::MakeXYWH(20, 0, 200, 100), 30, 30)),
      SkPath{}.addCircle(100, 50, 50),
      SkPath{}.addPoly(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()));
}

◆ TEST_P() [275/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawStrokedText
	)

Definition at line 466 of file dl_unittests.cc.

                                            {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setColor(flutter::DlColor::kRed());
  builder.DrawTextBlob(
      SkTextBlob::MakeFromString("stoked about stroked text", CreateTestFont()),
      250, 250, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [276/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextBlob
	)

Definition at line 56 of file dl_unittests.cc.

                                         {
  flutter::DisplayListBuilder builder;
  builder.DrawTextBlob(SkTextBlob::MakeFromString("Hello", CreateTestFont()),
                       100, 100, flutter::DlPaint(flutter::DlColor::kBlue()));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [277/450]

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::kClamp);
  flutter::DlPaint paint;
  paint.setColorSource(linear);
 
  builder.DrawTextBlob(
      SkTextBlob::MakeFromString("Hello World", CreateTestFont()), 100, 100,
      paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [278/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextWithSaveLayer
	)

Definition at line 82 of file dl_unittests.cc.

                                                  {
  flutter::DisplayListBuilder builder;
  builder.DrawTextBlob(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(nullptr, &save_paint);
  builder.DrawTextBlob(SkTextBlob::MakeFromString("Hello with half alpha",
                                                  CreateTestFontOfSize(100)),
                       100, 300, flutter::DlPaint(flutter::DlColor::kRed()));
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [279/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithBlendColorFilter
	)

Definition at line 518 of file dl_unittests.cc.

                                                     {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  // Pipeline blended image.
  {
    auto filter = flutter::DlBlendColorFilter(flutter::DlColor::kYellow(),
                                              flutter::DlBlendMode::kModulate);
    paint.setColorFilter(&filter);
    builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(100, 100),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
  }
 
  // Advanced blended image.
  {
    auto filter = flutter::DlBlendColorFilter(flutter::DlColor::kRed(),
                                              flutter::DlBlendMode::kScreen);
    paint.setColorFilter(&filter);
    builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(250, 250),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [280/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithColorFilterImageFilter
	)

Definition at line 544 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 =
      std::make_shared<flutter::DlMatrixColorFilter>(invert_color_matrix);
  auto image_filter =
      std::make_shared<flutter::DlColorFilterImageFilter>(color_filter);
 
  paint.setImageFilter(image_filter.get());
  builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
 
  builder.Translate(0, 700);
  paint.setColorFilter(color_filter.get());
  builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [281/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithComposeImageFilter
	)

Definition at line 596 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), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  builder.Translate(0, 700);
  paint.setImageFilter(close.get());
  builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [282/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithImageBlurFilter
	)

Definition at line 571 of file dl_unittests.cc.

                                                    {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
 
  auto callback = [&]() {
    static float sigma[] = {10, 10};
 
    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), SkPoint::Make(200, 200),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [283/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMaskBlur
	)

Definition at line 430 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), SkPoint::Make(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(SkRect::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.DrawTextBlob(
        SkTextBlob::MakeFromString("Testing", CreateTestFont()), 220, 170,
        paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [284/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMatrixFilter
	)

Definition at line 1010 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;
 
    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(nullptr, nullptr);
    }
    {
      auto content_scale = GetContentScale();
      builder.Scale(content_scale.x, content_scale.y);
 
      // Set the current transform
      auto ctm_matrix =
          SkMatrix::MakeAll(ctm_scale[0], ctm_skew[0], ctm_translation[0],  //
                            ctm_skew[1], ctm_scale[1], ctm_translation[1],  //
                            0, 0, 1);
      builder.Transform(ctm_matrix);
 
      // Set the matrix filter
      auto filter_matrix =
          SkMatrix::MakeAll(scale[0], skew[0], translation[0],  //
                            skew[1], scale[1], translation[1],  //
                            0, 0, 1);
 
      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), {},
                        flutter::DlImageSampling::kLinear, &paint);
    }
    if (enable_savelayer) {
      builder.Restore();
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [285/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMatrixFilterWhenSavingLayer
	)

Definition at line 1113 of file dl_unittests.cc.

                                                                {
  auto callback = [&]() {
    static float translation[2] = {0, 0};
    static bool enable_save_layer = true;
 
    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(SkRect::MakeWH(300, 300), paint);
    paint.setStrokeWidth(1.0);
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setColor(flutter::DlColor::kBlack().withAlpha(0x80));
    builder.DrawLine(SkPoint::Make(150, 0), SkPoint::Make(150, 300), paint);
    builder.DrawLine(SkPoint::Make(0, 150), SkPoint::Make(300, 150), paint);
 
    flutter::DlPaint save_paint;
    SkRect bounds = SkRect::MakeXYWH(100, 100, 100, 100);
    SkMatrix translate_matrix =
        SkMatrix::Translate(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);
    }
 
    SkMatrix filter_matrix = SkMatrix::I();
    filter_matrix.postTranslate(-150, -150);
    filter_matrix.postScale(0.2f, 0.2f);
    filter_matrix.postTranslate(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));
}

◆ TEST_P() [286/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithOddPathWinding
	)

Definition at line 386 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);
  SkPath path;
  path.setFillType(SkPathFillType::kEvenOdd);
  path.addCircle(0, 0, 100);
  path.addCircle(0, 0, 50);
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [287/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawZeroLengthLine
	)

Definition at line 841 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);
  SkPath path = SkPath().addPoly({{150, 50}, {150, 50}}, false);
  for (auto cap : caps) {
    paint.setStrokeCap(cap);
    builder.DrawLine({50, 50}, {50, 50}, paint);
    builder.DrawPath(path, paint);
    builder.Translate(0, 150);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [288/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawZeroWidthLine
	)

Definition at line 976 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);
  SkPath path = SkPath().addPoly({{150, 50}, {160, 50}}, false);
  for (auto cap : caps) {
    paint.setStrokeCap(cap);
    builder.DrawLine({50, 50}, {60, 50}, paint);
    builder.DrawRect({45, 45, 65, 55}, outline_paint);
    builder.DrawLine({100, 50}, {100, 50}, paint);
    if (cap != flutter::DlStrokeCap::kButt) {
      builder.DrawRect({95, 45, 105, 55}, outline_paint);
    }
    builder.DrawPath(path, paint);
    builder.DrawRect(path.getBounds().makeOutset(5, 5), outline_paint);
    builder.Translate(0, 150);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [289/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		ClipDrawRRectWithNonCircularRadii
	)

Definition at line 1393 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.DrawRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(500, 100, 300, 300), 120, 40),
      fill_paint);
  builder.DrawRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(500, 100, 300, 300), 120, 40),
      stroke_paint);
 
  builder.DrawRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(100, 500, 300, 300), 40, 120),
      fill_paint);
  builder.DrawRRect(
      SkRRect::MakeRectXY(SkRect::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.DrawRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(500, 500, 300, 300), 40, 40),
      reference_paint);
  builder.DrawRRect(
      SkRRect::MakeRectXY(SkRect::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.ClipRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(900, 100, 300, 300), 120, 40));
  builder.DrawPaint(clip_fill_paint);
  builder.Restore();
 
  builder.Save();
  builder.ClipRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(100, 900, 300, 300), 40, 120));
  builder.DrawPaint(clip_fill_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [290/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		DispatcherDoesNotCullPerspectiveTransformedChildDisplayLists
	)

Definition at line 913 of file dl_unittests.cc.

                                                                     {
  // Regression test for https://github.com/flutter/flutter/issues/130613
  flutter::DisplayListBuilder sub_builder(true);
  sub_builder.DrawRect(SkRect::MakeXYWH(0, 0, 50, 50),
                       flutter::DlPaint(flutter::DlColor::kRed()));
  auto display_list = sub_builder.Build();
 
  DlDispatcher dispatcher(Rect::MakeLTRB(0, 0, 2400, 1800));
  dispatcher.scale(2.0, 2.0);
  dispatcher.translate(-93.0, 0.0);
  // clang-format off
  dispatcher.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
  dispatcher.translate(35.0, 75.0);
  dispatcher.drawDisplayList(display_list, 1.0f);
  auto picture = dispatcher.EndRecordingAsPicture();
 
  bool found = false;
  picture.pass->IterateAllEntities([&found](Entity& entity) {
    if (std::static_pointer_cast<SolidColorContents>(entity.GetContents())
            ->GetColor() == Color::Red()) {
      found = true;
      return false;
    }
 
    return true;
  });
  EXPECT_TRUE(found);
}

◆ TEST_P() [291/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawMaskBlursThatMightUseSaveLayers
	)

Definition at line 1655 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(SkRect::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(
      SkMatrix::RotateDeg(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(SkRect::MakeXYWH(x * 100, y * 100, 80, 80),
                       normal_if_paint);
    }
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [292/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawPaintIgnoresMaskFilter
	)

Definition at line 1632 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({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()));
}

◆ TEST_P() [293/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawShapes
	)

Definition at line 1355 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);
  SkPath path = SkPath().addPoly({{150, 50}, {160, 50}}, false);
 
  builder.Translate(300, 50);
  builder.Scale(0.8, 0.8);
  for (auto join : joins) {
    paint.setStrokeJoin(join);
    stroke_paint.setStrokeJoin(join);
    builder.DrawRect(SkRect::MakeXYWH(0, 0, 100, 100), paint);
    builder.DrawRect(SkRect::MakeXYWH(0, 150, 100, 100), stroke_paint);
    builder.DrawRRect(
        SkRRect::MakeRectXY(SkRect::MakeXYWH(150, 0, 100, 100), 30, 30), paint);
    builder.DrawRRect(
        SkRRect::MakeRectXY(SkRect::MakeXYWH(150, 150, 100, 100), 30, 30),
        stroke_paint);
    builder.DrawCircle({350, 50}, 50, paint);
    builder.DrawCircle({350, 200}, 50, stroke_paint);
    builder.Translate(0, 300);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [294/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawVerticesBlendModes
	)

Definition at line 1455 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};
 
    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<SkPoint> positions = {SkPoint::Make(100, 300),
                                      SkPoint::Make(200, 100),
                                      SkPoint::Make(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));
}

◆ TEST_P() [295/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		IgnoreMaskFilterWhenSavingLayer
	)

Definition at line 505 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(nullptr, &paint);
  builder.DrawImage(DlImageImpeller::Make(texture), SkPoint::Make(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor);
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [296/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		MaskBlursApplyCorrectlyToColorSources
	)

Definition at line 1318 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};
  std::array<std::shared_ptr<flutter::DlColorSource>, 2> color_sources = {
      std::make_shared<flutter::DlColorColorSource>(flutter::DlColor::kWhite()),
      flutter::DlColorSource::MakeLinear(
          SkPoint::Make(0, 0), SkPoint::Make(100, 50), 2, colors.data(),
          stops.data(), flutter::DlTileMode::kClamp)};
 
  int offset = 100;
  for (const auto& color_source : color_sources) {
    flutter::DlPaint paint;
    paint.setColorSource(color_source);
    paint.setMaskFilter(blur_filter);
 
    paint.setDrawStyle(flutter::DlDrawStyle::kFill);
    builder.DrawRRect(
        SkRRect::MakeRectXY(SkRect::MakeXYWH(100, offset, 100, 50), 30, 30),
        paint);
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setStrokeWidth(10);
    builder.DrawRRect(
        SkRRect::MakeRectXY(SkRect::MakeXYWH(300, offset, 100, 50), 30, 30),
        paint);
 
    offset += 100;
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [297/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		NinePatchImagePrecision
	)

Definition at line 793 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),
                        SkIRect::MakeXYWH(10, 10, 1, 1),
                        SkRect::MakeXYWH(0, 0, 200, 100),
                        flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [298/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		StrokedPathsDrawCorrectly
	)

Definition at line 213 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"};
 
    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(SkRect::MakeSize({100, 100}), paint);
 
    // Rounded rectangle
    builder.Translate(150, 0);
    builder.DrawRRect(SkRRect::MakeRectXY(SkRect::MakeSize({100, 50}), 10, 10),
                      paint);
 
    // Double rounded rectangle
    builder.Translate(150, 0);
    builder.DrawDRRect(
        SkRRect::MakeRectXY(SkRect::MakeSize({100, 50}), 10, 10),
        SkRRect::MakeRectXY(SkRect::MakeXYWH(10, 10, 80, 30), 10, 10), paint);
 
    // Contour with duplicate join points
    {
      builder.Translate(150, 0);
      SkPath path;
      path.moveTo(0, 0);
      path.lineTo(0, 0);
      path.lineTo({100, 0});
      path.lineTo({100, 0});
      path.lineTo({100, 100});
      builder.DrawPath(path, paint);
    }
 
    // Contour with duplicate start and end points
 
    // Line.
    builder.Translate(200, 0);
    {
      builder.Save();
 
      SkPath line_path;
      line_path.moveTo(0, 0);
      line_path.moveTo(0, 0);
      line_path.lineTo({0, 0});
      line_path.lineTo({0, 0});
      line_path.lineTo({50, 50});
      line_path.lineTo({50, 50});
      line_path.lineTo({100, 0});
      line_path.lineTo({100, 0});
      builder.DrawPath(line_path, paint);
 
      builder.Translate(0, 100);
      builder.DrawPath(line_path, paint);
 
      builder.Translate(0, 100);
      SkPath line_path2;
      line_path2.moveTo(0, 0);
      line_path2.lineTo(0, 0);
      line_path2.lineTo(0, 0);
      builder.DrawPath(line_path2, paint);
 
      builder.Restore();
    }
 
    // Cubic.
    builder.Translate(150, 0);
    {
      builder.Save();
 
      SkPath cubic_path;
      cubic_path.moveTo({0, 0});
      cubic_path.cubicTo(0, 0, 140.0, 100.0, 140, 20);
      builder.DrawPath(cubic_path, paint);
 
      builder.Translate(0, 100);
      SkPath cubic_path2;
      cubic_path2.moveTo({0, 0});
      cubic_path2.cubicTo(0, 0, 0, 0, 150, 150);
      builder.DrawPath(cubic_path2, paint);
 
      builder.Translate(0, 100);
      SkPath cubic_path3;
      cubic_path3.moveTo({0, 0});
      cubic_path3.cubicTo(0, 0, 0, 0, 0, 0);
      builder.DrawPath(cubic_path3, paint);
 
      builder.Restore();
    }
 
    // Quad.
    builder.Translate(200, 0);
    {
      builder.Save();
 
      SkPath quad_path;
      quad_path.moveTo(0, 0);
      quad_path.moveTo(0, 0);
      quad_path.quadTo({100, 40}, {50, 80});
      builder.DrawPath(quad_path, paint);
 
      builder.Translate(0, 150);
      SkPath quad_path2;
      quad_path2.moveTo(0, 0);
      quad_path2.moveTo(0, 0);
      quad_path2.quadTo({0, 0}, {100, 100});
      builder.DrawPath(quad_path2, paint);
 
      builder.Translate(0, 100);
      SkPath quad_path3;
      quad_path3.moveTo(0, 0);
      quad_path3.quadTo({0, 0}, {0, 0});
      builder.DrawPath(quad_path3, paint);
 
      builder.Restore();
    }
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [299/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		StrokedTextNotOffsetFromNormalText
	)

Definition at line 480 of file dl_unittests.cc.

                                                            {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  auto const& text_blob = SkTextBlob::MakeFromString("00000", CreateTestFont());
 
  // 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(SkRect::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.DrawTextBlob(text_blob, 250, 250, paint);
 
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setColor(flutter::DlColor::kBlack());
  builder.DrawTextBlob(text_blob, 250, 250, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [300/450]

impeller::testing::TEST_P	(	DisplayListTest	,
		TransparentShadowProducesCorrectColor
	)

Definition at line 949 of file dl_unittests.cc.

                                                               {
  DlDispatcher dispatcher;
  dispatcher.save();
  dispatcher.scale(1.618, 1.618);
  SkPath path = SkPath{}.addRect(SkRect::MakeXYWH(0, 0, 200, 100));
  flutter::DlOpReceiver::CacheablePath cache(path);
  dispatcher.drawShadow(cache, flutter::DlColor::kTransparent(), 15, false, 1);
  dispatcher.restore();
  auto picture = dispatcher.EndRecordingAsPicture();
 
  std::shared_ptr<SolidRRectBlurContents> rrect_blur;
  picture.pass->IterateAllEntities([&rrect_blur](Entity& entity) {
    if (ScalarNearlyEqual(entity.GetTransform().GetScale().x, 1.618f)) {
      rrect_blur = std::static_pointer_cast<SolidRRectBlurContents>(
          entity.GetContents());
      return false;
    }
    return true;
  });
 
  ASSERT_NE(rrect_blur, nullptr);
  ASSERT_EQ(rrect_blur->GetColor().red, 0);
  ASSERT_EQ(rrect_blur->GetColor().green, 0);
  ASSERT_EQ(rrect_blur->GetColor().blue, 0);
  ASSERT_EQ(rrect_blur->GetColor().alpha, 0);
}

◆ TEST_P() [301/450]

impeller::testing::TEST_P	(	DriverInfoVKTest	,
		CanDumpToLog
	)

Definition at line 26 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();
  ASSERT_TRUE(log.str().find("Driver Information") != std::string::npos);
}

◆ TEST_P() [302/450]

impeller::testing::TEST_P	(	DriverInfoVKTest	,
		CanQueryDriverInfo
	)

Definition at line 14 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(), "");
}

◆ TEST_P() [303/450]

impeller::testing::TEST_P	(	EntityPassTargetTest	,
		SwapWithMSAAImplicitResolve
	)

Definition at line 53 of file entity_pass_target_unittests.cc.

                                                          {
  auto 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()
                    .GetColorAttachments()
                    .find(0u)
                    ->second;
  auto msaa_tex = color0.texture;
  auto resolve_tex = color0.resolve_texture;
 
  ASSERT_EQ(msaa_tex, resolve_tex);
 
  entity_pass_target.Flip(
      *content_context->GetContext()->GetResourceAllocator());
 
  color0 = entity_pass_target.GetRenderTarget()
               .GetColorAttachments()
               .find(0u)
               ->second;
 
  ASSERT_NE(msaa_tex, color0.texture);
  ASSERT_NE(resolve_tex, color0.resolve_texture);
  ASSERT_EQ(color0.texture, color0.resolve_texture);
}

◆ TEST_P() [304/450]

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.";
  }
  auto 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()
                    .GetColorAttachments()
                    .find(0u)
                    ->second;
  auto msaa_tex = color0.texture;
  auto resolve_tex = color0.resolve_texture;
 
  entity_pass_target.Flip(
      *content_context->GetContext()->GetResourceAllocator());
 
  color0 = entity_pass_target.GetRenderTarget()
               .GetColorAttachments()
               .find(0u)
               ->second;
 
  ASSERT_EQ(msaa_tex, color0.texture);
  ASSERT_NE(resolve_tex, color0.resolve_texture);
}

◆ TEST_P() [305/450]

impeller::testing::TEST_P	(	EntityTest	,
		AdvancedBlendCoverageHintIsNotResetByEntityPass
	)

Definition at line 2370 of file entity_unittests.cc.

                                                                    {
  if (GetContext()->GetCapabilities()->SupportsFramebufferFetch()) {
    GTEST_SKIP() << "Backends that support framebuffer fetch dont use coverage "
                    "for advanced blends.";
  }
 
  auto contents = std::make_shared<SolidColorContents>();
  contents->SetGeometry(Geometry::MakeRect(Rect::MakeXYWH(100, 100, 100, 100)));
  contents->SetColor(Color::Red());
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(Vector3(2, 2, 1)));
  entity.SetBlendMode(BlendMode::kColorBurn);
  entity.SetContents(contents);
 
  auto coverage = entity.GetCoverage();
  EXPECT_TRUE(coverage.has_value());
 
  auto pass = std::make_unique<EntityPass>();
  std::shared_ptr<RenderTargetCache> render_target_allocator =
      std::make_shared<RenderTargetCache>(GetContext()->GetResourceAllocator());
  auto stencil_config = RenderTarget::AttachmentConfig{
      .storage_mode = StorageMode::kDevicePrivate,
      .load_action = LoadAction::kClear,
      .store_action = StoreAction::kDontCare,
      .clear_color = Color::BlackTransparent()};
  auto rt = render_target_allocator->CreateOffscreen(
      *GetContext(), ISize::MakeWH(1000, 1000),
      /*mip_count=*/1, "Offscreen", RenderTarget::kDefaultColorAttachmentConfig,
      stencil_config);
  auto content_context = ContentContext(
      GetContext(), TypographerContextSkia::Make(), render_target_allocator);
  pass->AddEntity(std::move(entity));
 
  EXPECT_TRUE(pass->Render(content_context, rt));
 
  auto contains_size = [&render_target_allocator](ISize size) -> bool {
    return std::find_if(render_target_allocator->GetRenderTargetDataBegin(),
                        render_target_allocator->GetRenderTargetDataEnd(),
                        [&size](const auto& data) {
                          return data.config.size == size;
                        }) != render_target_allocator->GetRenderTargetDataEnd();
  };
 
  EXPECT_TRUE(contains_size(ISize(1000, 1000)))
      << "The root texture wasn't allocated";
  EXPECT_TRUE(contains_size(ISize(200, 200)))
      << "The ColorBurned texture wasn't allocated (100x100 scales up 2x)";
}

◆ TEST_P() [306/450]

impeller::testing::TEST_P	(	EntityTest	,
		BezierCircleScaled
	)

Definition at line 993 of file entity_unittests.cc.

                                       {
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    static float scale = 20;
 
    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
    ImGui::SliderFloat("Scale", &scale, 1, 100);
    ImGui::End();
 
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()));
    auto path = PathBuilder{}
                    .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}));
    entity.SetContents(SolidColorContents::Make(path, Color::Red()));
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [307/450]

impeller::testing::TEST_P	(	EntityTest	,
		BlendingModeOptions
	)

Definition at line 862 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::kSource:
        blend_mode_names.push_back("Source");
        blend_mode_values.push_back(BlendMode::kSource);
      case BlendMode::kDestination:
        blend_mode_names.push_back("Destination");
        blend_mode_values.push_back(BlendMode::kDestination);
      case BlendMode::kSourceOver:
        blend_mode_names.push_back("SourceOver");
        blend_mode_values.push_back(BlendMode::kSourceOver);
      case BlendMode::kDestinationOver:
        blend_mode_names.push_back("DestinationOver");
        blend_mode_values.push_back(BlendMode::kDestinationOver);
      case BlendMode::kSourceIn:
        blend_mode_names.push_back("SourceIn");
        blend_mode_values.push_back(BlendMode::kSourceIn);
      case BlendMode::kDestinationIn:
        blend_mode_names.push_back("DestinationIn");
        blend_mode_values.push_back(BlendMode::kDestinationIn);
      case BlendMode::kSourceOut:
        blend_mode_names.push_back("SourceOut");
        blend_mode_values.push_back(BlendMode::kSourceOut);
      case BlendMode::kDestinationOut:
        blend_mode_names.push_back("DestinationOut");
        blend_mode_values.push_back(BlendMode::kDestinationOut);
      case BlendMode::kSourceATop:
        blend_mode_names.push_back("SourceATop");
        blend_mode_values.push_back(BlendMode::kSourceATop);
      case BlendMode::kDestinationATop:
        blend_mode_names.push_back("DestinationATop");
        blend_mode_values.push_back(BlendMode::kDestinationATop);
      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.GetTransientsBuffer()));
 
      VS::FrameInfo frame_info;
      frame_info.mvp = pass.GetOrthographicTransform() * world_matrix;
      VS::BindFrameInfo(
          pass, context.GetTransientsBuffer().EmplaceUniform(frame_info));
      FS::FragInfo frag_info;
      frag_info.color = color.Premultiply();
      FS::BindFragInfo(
          pass, context.GetTransientsBuffer().EmplaceUniform(frame_info));
      return pass.Draw().ok();
    };
 
    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
    static Color color1(1, 0, 0, 0.5), color2(0, 1, 0, 0.5);
    ImGui::ColorEdit4("Color 1", reinterpret_cast<float*>(&color1));
    ImGui::ColorEdit4("Color 2", reinterpret_cast<float*>(&color2));
    static int current_blend_index = 3;
    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::kSourceOver);
    result = result && draw_rect(Rect::MakeLTRB(c.x, c.y, d.x, d.y), color2,
                                 selected_mode);
    return result;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [308/450]

impeller::testing::TEST_P	(	EntityTest	,
		BorderMaskBlurCoverageIsCorrect
	)

Definition at line 1394 of file entity_unittests.cc.

                                                    {
  auto fill = std::make_shared<SolidColorContents>();
  fill->SetGeometry(Geometry::MakeFillPath(
      PathBuilder{}.AddRect(Rect::MakeXYWH(0, 0, 300, 400)).TakePath()));
  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);
  }
}

◆ TEST_P() [309/450]

impeller::testing::TEST_P	(	EntityTest	,
		CanComputeGeometryForEmptyPathsWithoutCrashing
	)

Definition at line 2549 of file entity_unittests.cc.

                                                                   {
  PathBuilder builder = {};
  builder.AddRect(Rect::MakeLTRB(0, 0, 0, 0));
  Path path = builder.TakePath();
 
  EXPECT_TRUE(path.GetBoundingBox()->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);
}

◆ TEST_P() [310/450]

impeller::testing::TEST_P	(	EntityTest	,
		CanCreateEntity
	)

Definition at line 71 of file entity_unittests.cc.

                                    {
  Entity entity;
  ASSERT_TRUE(entity.GetTransform().IsIdentity());
}

◆ TEST_P() [311/450]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawCorrectlyWithRotatedTransform
	)

Definition at line 546 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;
    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*));
    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;
    }
 
    if (ImGui::Button("Reset")) {
      rotation = 0;
    }
    ImGui::End();
    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;
    Path path =
        PathBuilder{}.AddRect(Rect::MakeXYWH(-300, -400, 600, 800)).TakePath();
 
    Entity entity;
    entity.SetTransform(result_transform);
    entity.SetContents(SolidColorContents::Make(path, Color::Red()));
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [312/450]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawRect
	)

Definition at line 265 of file entity_unittests.cc.

                                {
  auto contents = std::make_shared<SolidColorContents>();
  contents->SetGeometry(Geometry::MakeRect(Rect::MakeXYWH(100, 100, 100, 100)));
  contents->SetColor(Color::Red());
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  entity.SetContents(contents);
 
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [313/450]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawRRect
	)

Definition at line 277 of file entity_unittests.cc.

                                 {
  auto contents = std::make_shared<SolidColorContents>();
  auto path = PathBuilder{}
                  .SetConvexity(Convexity::kConvex)
                  .AddRoundedRect(Rect::MakeXYWH(100, 100, 100, 100), 10.0)
                  .TakePath();
  contents->SetGeometry(Geometry::MakeFillPath(path));
  contents->SetColor(Color::Red());
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  entity.SetContents(contents);
 
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [314/450]

impeller::testing::TEST_P	(	EntityTest	,
		CanRenderEmptyPathsWithoutCrashing
	)

Definition at line 2571 of file entity_unittests.cc.

                                                       {
  PathBuilder builder = {};
  builder.AddRect(Rect::MakeLTRB(0, 0, 0, 0));
  Path path = builder.TakePath();
 
  EXPECT_TRUE(path.GetBoundingBox()->IsEmpty());
 
  auto contents = std::make_shared<SolidColorContents>();
  contents->SetGeometry(Geometry::MakeFillPath(path));
  contents->SetColor(Color::Red());
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  entity.SetContents(contents);
 
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [315/450]

impeller::testing::TEST_P	(	EntityTest	,
		ClipContentsGetClipCoverageIsCorrect
	)

Definition at line 1534 of file entity_unittests.cc.

                                                         {
  // Intersection: No stencil coverage, no geometry.
  {
    auto clip = std::make_shared<ClipContents>();
    clip->SetClipOperation(Entity::ClipOperation::kIntersect);
    auto result = clip->GetClipCoverage(Entity{}, Rect{});
 
    ASSERT_FALSE(result.coverage.has_value());
  }
 
  // Intersection: No stencil coverage, with geometry.
  {
    auto clip = std::make_shared<ClipContents>();
    clip->SetClipOperation(Entity::ClipOperation::kIntersect);
    clip->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(0, 0, 100, 100)).TakePath()));
    auto result = clip->GetClipCoverage(Entity{}, Rect{});
 
    ASSERT_FALSE(result.coverage.has_value());
  }
 
  // Intersection: With stencil coverage, no geometry.
  {
    auto clip = std::make_shared<ClipContents>();
    clip->SetClipOperation(Entity::ClipOperation::kIntersect);
    auto result =
        clip->GetClipCoverage(Entity{}, Rect::MakeLTRB(0, 0, 100, 100));
 
    ASSERT_FALSE(result.coverage.has_value());
  }
 
  // Intersection: With stencil coverage, with geometry.
  {
    auto clip = std::make_shared<ClipContents>();
    clip->SetClipOperation(Entity::ClipOperation::kIntersect);
    clip->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(0, 0, 50, 50)).TakePath()));
    auto result =
        clip->GetClipCoverage(Entity{}, Rect::MakeLTRB(0, 0, 100, 100));
 
    ASSERT_TRUE(result.coverage.has_value());
    ASSERT_RECT_NEAR(result.coverage.value(), Rect::MakeLTRB(0, 0, 50, 50));
    ASSERT_EQ(result.type, Contents::ClipCoverage::Type::kAppend);
  }
 
  // Difference: With stencil coverage, with geometry.
  {
    auto clip = std::make_shared<ClipContents>();
    clip->SetClipOperation(Entity::ClipOperation::kDifference);
    clip->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(0, 0, 50, 50)).TakePath()));
    auto result =
        clip->GetClipCoverage(Entity{}, Rect::MakeLTRB(0, 0, 100, 100));
 
    ASSERT_TRUE(result.coverage.has_value());
    ASSERT_RECT_NEAR(result.coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
    ASSERT_EQ(result.type, Contents::ClipCoverage::Type::kAppend);
  }
}

◆ TEST_P() [316/450]

impeller::testing::TEST_P	(	EntityTest	,
		ClipContentsOptimizesFullScreenIntersectClips
	)

Definition at line 23 of file clip_contents_unittests.cc.

                                                                  {
  // Set up mock environment.
 
  auto 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);
 
  // Set up clip contents.
 
  auto contents = std::make_shared<ClipContents>();
  contents->SetClipOperation(Entity::ClipOperation::kIntersect);
  contents->SetGeometry(Geometry::MakeCover());
 
  Entity entity;
  entity.SetContents(std::move(contents));
 
  // Render the clip contents.
 
  ASSERT_TRUE(recording_pass->GetCommands().empty());
  ASSERT_TRUE(entity.Render(*content_context, *recording_pass));
  ASSERT_FALSE(recording_pass->GetCommands().empty());
}

◆ TEST_P() [317/450]

impeller::testing::TEST_P	(	EntityTest	,
		ClipContentsShouldRenderIsCorrect
	)

Definition at line 1510 of file entity_unittests.cc.

                                                      {
  // For clip ops, `ShouldRender` should always return true.
 
  // Clip.
  {
    auto clip = std::make_shared<ClipContents>();
    ASSERT_TRUE(clip->ShouldRender(Entity{}, Rect::MakeSize(Size{100, 100})));
    clip->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(0, 0, 100, 100)).TakePath()));
    ASSERT_TRUE(clip->ShouldRender(Entity{}, Rect::MakeSize(Size{100, 100})));
    ASSERT_TRUE(
        clip->ShouldRender(Entity{}, Rect::MakeLTRB(-100, -100, -50, -50)));
  }
 
  // Clip restore.
  {
    auto restore = std::make_shared<ClipRestoreContents>();
    ASSERT_TRUE(
        restore->ShouldRender(Entity{}, Rect::MakeSize(Size{100, 100})));
    ASSERT_TRUE(
        restore->ShouldRender(Entity{}, Rect::MakeLTRB(-100, -100, -50, -50)));
  }
}

◆ TEST_P() [318/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterContentsWithLargeGeometry
	)

Definition at line 2342 of file entity_unittests.cc.

                                                         {
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  auto src_contents = std::make_shared<SolidColorContents>();
  src_contents->SetGeometry(
      Geometry::MakeRect(Rect::MakeLTRB(-300, -500, 30000, 50000)));
  src_contents->SetColor(Color::Red());
 
  auto dst_contents = std::make_shared<SolidColorContents>();
  dst_contents->SetGeometry(
      Geometry::MakeRect(Rect::MakeLTRB(300, 500, 20000, 30000)));
  dst_contents->SetColor(Color::Blue());
 
  auto contents = ColorFilterContents::MakeBlend(
      BlendMode::kSourceOver, {FilterInput::Make(dst_contents, false),
                               FilterInput::Make(src_contents, false)});
  entity.SetContents(std::move(contents));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [319/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorAdvancedBlend
	)

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

◆ TEST_P() [320/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorClearBlend
	)

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

◆ TEST_P() [321/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorDstBlend
	)

Definition at line 2223 of file entity_unittests.cc.

                                                           {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kDestination, 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));
}

◆ TEST_P() [322/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorSrcBlend
	)

Definition at line 2207 of file entity_unittests.cc.

                                                           {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kSource, 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));
}

◆ TEST_P() [323/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorSrcInBlend
	)

Definition at line 2239 of file entity_unittests.cc.

                                                             {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kSourceIn, 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));
}

◆ TEST_P() [324/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorMatrixFilterCoverageIsCorrect
	)

Definition at line 1647 of file entity_unittests.cc.

                                                       {
  // Set up a simple color background.
  auto fill = std::make_shared<SolidColorContents>();
  fill->SetGeometry(Geometry::MakeFillPath(
      PathBuilder{}.AddRect(Rect::MakeXYWH(0, 0, 300, 400)).TakePath()));
  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);
}

◆ TEST_P() [325/450]

impeller::testing::TEST_P	(	EntityTest	,
		ColorMatrixFilterEditable
	)

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

◆ TEST_P() [326/450]

impeller::testing::TEST_P	(	EntityTest	,
		ConicalGradientContentsIsOpaque
	)

Definition at line 2283 of file entity_unittests.cc.

                                                    {
  ConicalGradientContents contents;
  contents.SetColors({Color::CornflowerBlue()});
  ASSERT_FALSE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  ASSERT_FALSE(contents.IsOpaque());
}

◆ TEST_P() [327/450]

impeller::testing::TEST_P	(	EntityTest	,
		ContentContextOptionsHasReasonableHashFunctions
	)

Definition at line 2459 of file entity_unittests.cc.

                                                                    {
  ContentContextOptions opts;
  auto hash_a = ContentContextOptions::Hash{}(opts);
 
  opts.blend_mode = BlendMode::kColorBurn;
  auto hash_b = ContentContextOptions::Hash{}(opts);
 
  opts.has_depth_stencil_attachments = false;
  auto hash_c = ContentContextOptions::Hash{}(opts);
 
  opts.primitive_type = PrimitiveType::kPoint;
  auto hash_d = ContentContextOptions::Hash{}(opts);
 
  EXPECT_NE(hash_a, hash_b);
  EXPECT_NE(hash_b, hash_c);
  EXPECT_NE(hash_c, hash_d);
}

◆ TEST_P() [328/450]

impeller::testing::TEST_P	(	EntityTest	,
		ContentsGetBoundsForEmptyPathReturnsNullopt
	)

Definition at line 1335 of file entity_unittests.cc.

                                                                {
  Entity entity;
  entity.SetContents(std::make_shared<SolidColorContents>());
  ASSERT_FALSE(entity.GetCoverage().has_value());
}

◆ TEST_P() [329/450]

impeller::testing::TEST_P	(	EntityTest	,
		CoverageForStrokePathWithNegativeValuesInTransform
	)

Definition at line 2255 of file entity_unittests.cc.

                                                                       {
  auto arrow_head = PathBuilder{}
                        .MoveTo({50, 120})
                        .LineTo({120, 190})
                        .LineTo({190, 120})
                        .TakePath();
  auto geometry = Geometry::MakeStrokePath(arrow_head, 15.0, 4.0, Cap::kRound,
                                           Join::kRound);
 
  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));
}

◆ TEST_P() [330/450]

impeller::testing::TEST_P	(	EntityTest	,
		CubicCurveAndOverlapTest
	)

Definition at line 592 of file entity_unittests.cc.

                                             {
  // Compare with https://fiddle.skia.org/c/7a05a3e186c65a8dfb732f68020aae06
  Path path =
      PathBuilder{}
          .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()));
  entity.SetContents(SolidColorContents::Make(path, Color::Red()));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [331/450]

impeller::testing::TEST_P	(	EntityTest	,
		CubicCurveTest
	)

Definition at line 524 of file entity_unittests.cc.

                                   {
  // Compare with https://fiddle.skia.org/c/b3625f26122c9de7afe7794fcf25ead3
  Path path =
      PathBuilder{}
          .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()));
  entity.SetContents(SolidColorContents::Make(path, Color::Red()));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [332/450]

impeller::testing::TEST_P	(	EntityTest	,
		DecalSpecializationAppliedToMorphologyFilter
	)

Definition at line 2443 of file entity_unittests.cc.

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

◆ TEST_P() [333/450]

impeller::testing::TEST_P	(	EntityTest	,
		DoesNotCullEntitiesByDefault
	)

Definition at line 1496 of file entity_unittests.cc.

                                                 {
  auto fill = std::make_shared<SolidColorContents>();
  fill->SetColor(Color::CornflowerBlue());
  fill->SetGeometry(
      Geometry::MakeRect(Rect::MakeLTRB(-1000, -1000, -900, -900)));
 
  Entity entity;
  entity.SetContents(fill);
 
  // Even though the entity is offscreen, this should still render because we do
  // not compute the coverage intersection by default.
  EXPECT_TRUE(entity.ShouldRender(Rect::MakeLTRB(0, 0, 100, 100)));
}

◆ TEST_P() [334/450]

impeller::testing::TEST_P	(	EntityTest	,
		EntityPassCanMergeSubpassIntoParent
	)

Definition at line 188 of file entity_unittests.cc.

                                                        {
  // Both a red and a blue box should appear if the pass merging has worked
  // correctly.
 
  EntityPass pass;
  auto subpass = CreatePassWithRectPath(Rect::MakeLTRB(0, 0, 100, 100),
                                        Rect::MakeLTRB(50, 50, 150, 150),
                                        ContentBoundsPromise::kUnknown, true);
  pass.AddSubpass(std::move(subpass));
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  auto contents = std::make_unique<SolidColorContents>();
  contents->SetGeometry(Geometry::MakeRect(Rect::MakeLTRB(100, 100, 200, 200)));
  contents->SetColor(Color::Blue());
  entity.SetContents(std::move(contents));
 
  pass.AddEntity(std::move(entity));
 
  ASSERT_TRUE(OpenPlaygroundHere(pass));
}

◆ TEST_P() [335/450]

impeller::testing::TEST_P	(	EntityTest	,
		EntityPassCoverageRespectsCoverageLimit
	)

Definition at line 210 of file entity_unittests.cc.

                                                            {
  // Rect is drawn entirely in negative area.
  auto pass = CreatePassWithRectPath(Rect::MakeLTRB(-200, -200, -100, -100),
                                     std::nullopt);
 
  // Without coverage limit.
  {
    auto pass_coverage = pass->GetElementsCoverage(std::nullopt);
    ASSERT_TRUE(pass_coverage.has_value());
    ASSERT_RECT_NEAR(pass_coverage.value(),
                     Rect::MakeLTRB(-200, -200, -100, -100));
  }
 
  // With limit that doesn't overlap.
  {
    auto pass_coverage =
        pass->GetElementsCoverage(Rect::MakeLTRB(0, 0, 100, 100));
    ASSERT_FALSE(pass_coverage.has_value());
  }
 
  // With limit that partially overlaps.
  {
    auto pass_coverage =
        pass->GetElementsCoverage(Rect::MakeLTRB(-150, -150, 0, 0));
    ASSERT_TRUE(pass_coverage.has_value());
    ASSERT_RECT_NEAR(pass_coverage.value(),
                     Rect::MakeLTRB(-150, -150, -100, -100));
  }
}

◆ TEST_P() [336/450]

impeller::testing::TEST_P	(	EntityTest	,
		EntityPassRespectsUntrustedSubpassBoundsLimit
	)

Definition at line 125 of file entity_unittests.cc.

                                                                  {
  EntityPass pass;
 
  auto subpass0 = CreatePassWithRectPath(Rect::MakeLTRB(0, 0, 100, 100),
                                         Rect::MakeLTRB(50, 50, 150, 150));
  auto subpass1 = CreatePassWithRectPath(Rect::MakeLTRB(500, 500, 1000, 1000),
                                         Rect::MakeLTRB(800, 800, 900, 900));
 
  auto subpass0_coverage =
      pass.GetSubpassCoverage(*subpass0.get(), std::nullopt);
  ASSERT_TRUE(subpass0_coverage.has_value());
  ASSERT_RECT_NEAR(subpass0_coverage.value(), Rect::MakeLTRB(50, 50, 100, 100));
 
  auto subpass1_coverage =
      pass.GetSubpassCoverage(*subpass1.get(), std::nullopt);
  ASSERT_TRUE(subpass1_coverage.has_value());
  ASSERT_RECT_NEAR(subpass1_coverage.value(),
                   Rect::MakeLTRB(800, 800, 900, 900));
 
  pass.AddSubpass(std::move(subpass0));
  pass.AddSubpass(std::move(subpass1));
 
  auto coverage = pass.GetElementsCoverage(std::nullopt);
  ASSERT_TRUE(coverage.has_value());
  ASSERT_RECT_NEAR(coverage.value(), Rect::MakeLTRB(50, 50, 900, 900));
}

◆ TEST_P() [337/450]

impeller::testing::TEST_P	(	EntityTest	,
		EntityPassTrustsSnugSubpassBoundsLimit
	)

Definition at line 152 of file entity_unittests.cc.

                                                           {
  EntityPass pass;
 
  auto subpass0 =  //
      CreatePassWithRectPath(Rect::MakeLTRB(10, 10, 90, 90),
                             Rect::MakeLTRB(5, 5, 95, 95),
                             ContentBoundsPromise::kContainsContents);
  auto subpass1 =  //
      CreatePassWithRectPath(Rect::MakeLTRB(500, 500, 1000, 1000),
                             Rect::MakeLTRB(495, 495, 1005, 1005),
                             ContentBoundsPromise::kContainsContents);
 
  auto subpass0_coverage =
      pass.GetSubpassCoverage(*subpass0.get(), std::nullopt);
  EXPECT_TRUE(subpass0_coverage.has_value());
  // Result should be the overridden bounds
  // (we lied about them being snug, but the property is respected)
  EXPECT_RECT_NEAR(subpass0_coverage.value(), Rect::MakeLTRB(5, 5, 95, 95));
 
  auto subpass1_coverage =
      pass.GetSubpassCoverage(*subpass1.get(), std::nullopt);
  EXPECT_TRUE(subpass1_coverage.has_value());
  // Result should be the overridden bounds
  // (we lied about them being snug, but the property is respected)
  EXPECT_RECT_NEAR(subpass1_coverage.value(),
                   Rect::MakeLTRB(495, 495, 1005, 1005));
 
  pass.AddSubpass(std::move(subpass0));
  pass.AddSubpass(std::move(subpass1));
 
  auto coverage = pass.GetElementsCoverage(std::nullopt);
  EXPECT_TRUE(coverage.has_value());
  // This result should be the union of the overridden bounds
  EXPECT_RECT_NEAR(coverage.value(), Rect::MakeLTRB(5, 5, 1005, 1005));
}

◆ TEST_P() [338/450]

impeller::testing::TEST_P	(	EntityTest	,
		FailOnValidationError
	)

Definition at line 2535 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,
      }),
      "");
}

◆ TEST_P() [339/450]

impeller::testing::TEST_P	(	EntityTest	,
		FillPathGeometryGetPositionBufferReturnsExpectedMode
	)

Definition at line 2501 of file entity_unittests.cc.

                                                                         {
  RenderTarget target;
  testing::MockRenderPass mock_pass(GetContext(), target);
 
  auto get_result = [this, &mock_pass](const Path& 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(PathBuilder{}
                       .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                       .SetConvexity(Convexity::kConvex)
                       .TakePath());
    EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal);
  }
 
  // Concave path
  {
    Path path = PathBuilder{}
                    .MoveTo({0, 0})
                    .LineTo({100, 0})
                    .LineTo({100, 100})
                    .LineTo({50, 50})
                    .Close()
                    .TakePath();
    GeometryResult result = get_result(path);
    EXPECT_EQ(result.mode, GeometryResult::Mode::kNonZero);
  }
}

◆ TEST_P() [340/450]

impeller::testing::TEST_P	(	EntityTest	,
		FilterCoverageRespectsCropRect
	)

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

◆ TEST_P() [341/450]

impeller::testing::TEST_P	(	EntityTest	,
		Filters
	)

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

◆ TEST_P() [342/450]

impeller::testing::TEST_P	(	EntityTest	,
		GaussianBlurFilter
	)

Definition at line 1055 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)};
 
    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]);
    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 {
      auto fill = std::make_shared<SolidColorContents>();
      fill->SetColor(input_color);
      fill->SetGeometry(
          Geometry::MakeFillPath(PathBuilder{}.AddRect(input_rect).TakePath()));
 
      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], 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], 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;
    cover_entity.SetContents(SolidColorContents::Make(
        PathBuilder{}.AddRect(input_rect).TakePath(), cover_color));
    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()) {
      bounds_entity.SetContents(SolidColorContents::Make(
          PathBuilder{}
              .AddRect(target_contents->GetCoverage(entity).value())
              .TakePath(),
          bounds_color));
      bounds_entity.SetTransform(Matrix());
 
      bounds_entity.Render(context, pass);
    }
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [343/450]

impeller::testing::TEST_P	(	EntityTest	,
		GeometryBoundsAreTransformed
	)

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

◆ TEST_P() [344/450]

impeller::testing::TEST_P	(	EntityTest	,
		InheritOpacityTest
	)

Definition at line 2125 of file entity_unittests.cc.

                                       {
  Entity entity;
 
  // Texture contents can always accept opacity.
  auto texture_contents = std::make_shared<TextureContents>();
  texture_contents->SetOpacity(0.5);
  ASSERT_TRUE(texture_contents->CanInheritOpacity(entity));
 
  texture_contents->SetInheritedOpacity(0.5);
  ASSERT_EQ(texture_contents->GetOpacity(), 0.25);
  texture_contents->SetInheritedOpacity(0.5);
  ASSERT_EQ(texture_contents->GetOpacity(), 0.25);
 
  // Solid color contents can accept opacity if their geometry
  // doesn't overlap.
  auto solid_color = std::make_shared<SolidColorContents>();
  solid_color->SetGeometry(
      Geometry::MakeRect(Rect::MakeLTRB(100, 100, 200, 200)));
  solid_color->SetColor(Color::Blue().WithAlpha(0.5));
 
  ASSERT_TRUE(solid_color->CanInheritOpacity(entity));
 
  solid_color->SetInheritedOpacity(0.5);
  ASSERT_EQ(solid_color->GetColor().alpha, 0.25);
  solid_color->SetInheritedOpacity(0.5);
  ASSERT_EQ(solid_color->GetColor().alpha, 0.25);
 
  // Color source contents can accept opacity if their geometry
  // doesn't overlap.
  auto tiled_texture = std::make_shared<TiledTextureContents>();
  tiled_texture->SetGeometry(
      Geometry::MakeRect(Rect::MakeLTRB(100, 100, 200, 200)));
  tiled_texture->SetOpacityFactor(0.5);
 
  ASSERT_TRUE(tiled_texture->CanInheritOpacity(entity));
 
  tiled_texture->SetInheritedOpacity(0.5);
  ASSERT_EQ(tiled_texture->GetOpacityFactor(), 0.25);
  tiled_texture->SetInheritedOpacity(0.5);
  ASSERT_EQ(tiled_texture->GetOpacityFactor(), 0.25);
 
  // Clips and restores trivially accept opacity.
  ASSERT_TRUE(ClipContents().CanInheritOpacity(entity));
  ASSERT_TRUE(ClipRestoreContents().CanInheritOpacity(entity));
 
  // Runtime effect contents can't accept opacity.
  auto runtime_effect = std::make_shared<RuntimeEffectContents>();
  ASSERT_FALSE(runtime_effect->CanInheritOpacity(entity));
}

◆ TEST_P() [345/450]

impeller::testing::TEST_P	(	EntityTest	,
		LinearGradientContentsIsOpaque
	)

Definition at line 2291 of file entity_unittests.cc.

                                                   {
  LinearGradientContents contents;
  contents.SetColors({Color::CornflowerBlue()});
  ASSERT_TRUE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  ASSERT_FALSE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue()});
  contents.SetTileMode(Entity::TileMode::kDecal);
  ASSERT_FALSE(contents.IsOpaque());
}

◆ TEST_P() [346/450]

impeller::testing::TEST_P	(	EntityTest	,
		LinearToSrgbFilter
	)

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

◆ TEST_P() [347/450]

impeller::testing::TEST_P	(	EntityTest	,
		LinearToSrgbFilterCoverageIsCorrect
	)

Definition at line 1734 of file entity_unittests.cc.

                                                        {
  // Set up a simple color background.
  auto fill = std::make_shared<SolidColorContents>();
  fill->SetGeometry(Geometry::MakeFillPath(
      PathBuilder{}.AddRect(Rect::MakeXYWH(0, 0, 300, 400)).TakePath()));
  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);
}

◆ TEST_P() [348/450]

impeller::testing::TEST_P	(	EntityTest	,
		MorphologyFilter
	)

Definition at line 1228 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;
 
    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;
    cover_entity.SetContents(SolidColorContents::Make(
        PathBuilder{}.AddRect(input_rect).TakePath(), cover_color));
    cover_entity.SetTransform(ctm);
 
    cover_entity.Render(context, pass);
 
    // Renders a green bounding rect of the target filter.
    Entity bounds_entity;
    bounds_entity.SetContents(SolidColorContents::Make(
        PathBuilder{}.AddRect(contents->GetCoverage(entity).value()).TakePath(),
        bounds_color));
    bounds_entity.SetTransform(Matrix());
 
    bounds_entity.Render(context, pass);
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [349/450]

impeller::testing::TEST_P	(	EntityTest	,
		PointFieldGeometryCoverage
	)

Definition at line 2334 of file entity_unittests.cc.

                                               {
  std::vector<Point> points = {{10, 20}, {100, 200}};
  auto geometry = Geometry::MakePointField(points, 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));
}

◆ TEST_P() [350/450]

impeller::testing::TEST_P	(	EntityTest	,
		RadialGradientContentsIsOpaque
	)

Definition at line 2302 of file entity_unittests.cc.

                                                   {
  RadialGradientContents contents;
  contents.SetColors({Color::CornflowerBlue()});
  ASSERT_TRUE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  ASSERT_FALSE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue()});
  contents.SetTileMode(Entity::TileMode::kDecal);
  ASSERT_FALSE(contents.IsOpaque());
}

◆ TEST_P() [351/450]

impeller::testing::TEST_P	(	EntityTest	,
		RRectShadowTest
	)

Definition at line 1594 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);
 
    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();
 
    static PlaygroundPoint top_left_point(Point(200, 200), 30, Color::White());
    static PlaygroundPoint bottom_right_point(Point(600, 400), 30,
                                              Color::White());
    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->SetRRect(rect, {corner_radius, 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 bounds_contents = std::make_unique<SolidColorContents>();
      bounds_contents->SetGeometry(Geometry::MakeFillPath(
          PathBuilder{}.AddRect(entity.GetCoverage().value()).TakePath()));
      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));
}

◆ TEST_P() [352/450]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffect
	)

Definition at line 1949 of file entity_unittests.cc.

                                  {
  auto runtime_stages =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  auto runtime_stage =
      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  bool expect_dirty = true;
  Pipeline<PipelineDescriptor>* first_pipeline;
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    EXPECT_EQ(runtime_stage->IsDirty(), expect_dirty);
 
    auto contents = std::make_shared<RuntimeEffectContents>();
    contents->SetGeometry(Geometry::MakeCover());
    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) {
      EXPECT_NE(first_pipeline, pass.GetCommands().back().pipeline.get());
      first_pipeline = pass.GetCommands().back().pipeline.get();
    } else {
      EXPECT_EQ(pass.GetCommands().back().pipeline.get(), first_pipeline);
    }
 
    expect_dirty = false;
    return result;
  };
 
  // Simulate some renders and hot reloading of the shader.
  auto 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.
    runtime_stages = OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
    runtime_stage =
        runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
 
    ASSERT_TRUE(runtime_stage->IsDirty());
    expect_dirty = true;
 
    callback(*content_context, mock_pass);
  }
}

◆ TEST_P() [353/450]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectCanPrecache
	)

Definition at line 2063 of file entity_unittests.cc.

                                             {
  auto runtime_stages =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  auto runtime_stage =
      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  auto contents = std::make_shared<RuntimeEffectContents>();
  contents->SetRuntimeStage(runtime_stage);
 
  EXPECT_TRUE(contents->BootstrapShader(*GetContentContext()));
}

◆ TEST_P() [354/450]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectCanSuccessfullyRender
	)

Definition at line 2016 of file entity_unittests.cc.

                                                       {
  auto runtime_stages =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  auto runtime_stage =
      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  auto contents = std::make_shared<RuntimeEffectContents>();
  contents->SetGeometry(Geometry::MakeCover());
 
  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());
}

◆ TEST_P() [355/450]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectSetsRightSizeWhenUniformIsStruct
	)

Definition at line 2077 of file entity_unittests.cc.

                                                                  {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only applies to Vulkan";
  }
 
  auto runtime_stages =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  auto runtime_stage =
      runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  auto contents = std::make_shared<RuntimeEffectContents>();
  contents->SetGeometry(Geometry::MakeCover());
  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);
 
  auto context = GetContentContext();
  RenderTarget target = context->GetRenderTargetCache()->CreateOffscreen(
      *context->GetContext(), {1, 1}, 1u);
 
  testing::MockRenderPass pass(GetContext(), target);
  ASSERT_TRUE(contents->Render(*context, entity, pass));
  ASSERT_EQ(pass.GetCommands().size(), 1u);
  const auto& command = pass.GetCommands()[0];
  ASSERT_EQ(command.fragment_bindings.buffers.size(), 1u);
  // 16 bytes:
  //   8 bytes for iResolution
  //   4 bytes for iTime
  //   4 bytes padding
  EXPECT_EQ(command.fragment_bindings.buffers[0].view.resource.range.length,
            16u);
}

◆ TEST_P() [356/450]

impeller::testing::TEST_P	(	EntityTest	,
		SetBlendMode
	)

Definition at line 1328 of file entity_unittests.cc.

                                 {
  Entity entity;
  ASSERT_EQ(entity.GetBlendMode(), BlendMode::kSourceOver);
  entity.SetBlendMode(BlendMode::kClear);
  ASSERT_EQ(entity.GetBlendMode(), BlendMode::kClear);
}

◆ TEST_P() [357/450]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsIsOpaque
	)

Definition at line 2275 of file entity_unittests.cc.

                                               {
  SolidColorContents contents;
  contents.SetColor(Color::CornflowerBlue());
  ASSERT_TRUE(contents.IsOpaque());
  contents.SetColor(Color::CornflowerBlue().WithAlpha(0.5));
  ASSERT_FALSE(contents.IsOpaque());
}

◆ TEST_P() [358/450]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsStrokeSetMiterLimit
	)

Definition at line 842 of file entity_unittests.cc.

                                                          {
  {
    auto geometry = Geometry::MakeStrokePath(Path{});
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(Path{}, 1.0, /*miter_limit=*/8.0);
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 8);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(Path{}, 1.0, /*miter_limit=*/-1.0);
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
  }
}

◆ TEST_P() [359/450]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsStrokeSetStrokeCapsAndJoins
	)

Definition at line 820 of file entity_unittests.cc.

                                                                  {
  {
    auto geometry = Geometry::MakeStrokePath(Path{});
    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(Path{}, 1.0, 4.0, Cap::kSquare);
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kSquare);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(Path{}, 1.0, 4.0, Cap::kRound);
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kRound);
  }
}

◆ TEST_P() [360/450]

impeller::testing::TEST_P	(	EntityTest	,
		SolidFillCoverageIsCorrect
	)

Definition at line 1421 of file entity_unittests.cc.

                                               {
  // No transform
  {
    auto fill = std::make_shared<SolidColorContents>();
    fill->SetColor(Color::CornflowerBlue());
    auto expected = Rect::MakeLTRB(100, 110, 200, 220);
    fill->SetGeometry(
        Geometry::MakeFillPath(PathBuilder{}.AddRect(expected).TakePath()));
 
    auto coverage = fill->GetCoverage({});
    ASSERT_TRUE(coverage.has_value());
    ASSERT_RECT_NEAR(coverage.value(), expected);
  }
 
  // Entity transform
  {
    auto fill = std::make_shared<SolidColorContents>();
    fill->SetColor(Color::CornflowerBlue());
    fill->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(100, 110, 200, 220)).TakePath()));
 
    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 fill = std::make_shared<SolidColorContents>();
    fill->SetColor(Color::WhiteTransparent());
    fill->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(100, 110, 200, 220)).TakePath()));
 
    auto coverage = fill->GetCoverage({});
    ASSERT_FALSE(coverage.has_value());
  }
}

◆ TEST_P() [361/450]

impeller::testing::TEST_P	(	EntityTest	,
		SolidFillShouldRenderIsCorrect
	)

Definition at line 1464 of file entity_unittests.cc.

                                                   {
  // No path.
  {
    auto fill = std::make_shared<SolidColorContents>();
    fill->SetColor(Color::CornflowerBlue());
    ASSERT_FALSE(fill->ShouldRender(Entity{}, Rect::MakeSize(Size{100, 100})));
    ASSERT_FALSE(
        fill->ShouldRender(Entity{}, Rect::MakeLTRB(-100, -100, -50, -50)));
  }
 
  // With path.
  {
    auto fill = std::make_shared<SolidColorContents>();
    fill->SetColor(Color::CornflowerBlue());
    fill->SetGeometry(Geometry::MakeFillPath(
        PathBuilder{}.AddRect(Rect::MakeLTRB(0, 0, 100, 100)).TakePath()));
    ASSERT_TRUE(fill->ShouldRender(Entity{}, Rect::MakeSize(Size{100, 100})));
    ASSERT_FALSE(
        fill->ShouldRender(Entity{}, Rect::MakeLTRB(-100, -100, -50, -50)));
  }
 
  // With paint cover.
  {
    auto fill = std::make_shared<SolidColorContents>();
    fill->SetColor(Color::CornflowerBlue());
    fill->SetGeometry(Geometry::MakeCover());
    ASSERT_TRUE(fill->ShouldRender(Entity{}, Rect::MakeSize(Size{100, 100})));
    ASSERT_TRUE(
        fill->ShouldRender(Entity{}, Rect::MakeLTRB(-100, -100, -50, -50)));
  }
}

◆ TEST_P() [362/450]

impeller::testing::TEST_P	(	EntityTest	,
		SolidStrokeCoverageIsCorrect
	)

Definition at line 1341 of file entity_unittests.cc.

                                                 {
  {
    auto geometry = Geometry::MakeStrokePath(
        PathBuilder{}.AddLine({0, 0}, {10, 10}).TakePath(), 4.0, 4.0,
        Cap::kButt, Join::kBevel);
 
    Entity entity;
    auto contents = std::make_unique<SolidColorContents>();
    contents->SetGeometry(std::move(geometry));
    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(
        PathBuilder{}.AddLine({0, 0}, {10, 10}).TakePath(), 4.0, 4.0,
        Cap::kSquare, Join::kBevel);
 
    Entity entity;
    auto contents = std::make_unique<SolidColorContents>();
    contents->SetGeometry(std::move(geometry));
    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(
        PathBuilder{}.AddLine({0, 0}, {10, 10}).TakePath(), 4.0, 2.0,
        Cap::kSquare, Join::kMiter);
 
    Entity entity;
    auto contents = std::make_unique<SolidColorContents>();
    contents->SetGeometry(std::move(geometry));
    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);
  }
}

◆ TEST_P() [363/450]

impeller::testing::TEST_P	(	EntityTest	,
		SpecializationConstantsAreAppliedToVariants
	)

Definition at line 2420 of file entity_unittests.cc.

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

◆ TEST_P() [364/450]

impeller::testing::TEST_P	(	EntityTest	,
		SrgbToLinearFilter
	)

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

◆ TEST_P() [365/450]

impeller::testing::TEST_P	(	EntityTest	,
		SrgbToLinearFilterCoverageIsCorrect
	)

Definition at line 1786 of file entity_unittests.cc.

                                                        {
  // Set up a simple color background.
  auto fill = std::make_shared<SolidColorContents>();
  fill->SetGeometry(Geometry::MakeFillPath(
      PathBuilder{}.AddRect(Rect::MakeXYWH(0, 0, 300, 400)).TakePath()));
  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);
}

◆ TEST_P() [366/450]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeCapAndJoinTest
	)

Definition at line 384 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;
 
    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 Path& path, Cap cap, Join join) {
      auto contents = std::make_unique<SolidColorContents>();
      contents->SetGeometry(
          Geometry::MakeStrokePath(path, width, miter_limit, cap, join));
      contents->SetColor(Color::Red());
 
      Entity entity;
      entity.SetTransform(world_matrix);
      entity.SetContents(std::move(contents));
 
      auto coverage = entity.GetCoverage();
      if (coverage.has_value()) {
        auto bounds_contents = std::make_unique<SolidColorContents>();
        bounds_contents->SetGeometry(Geometry::MakeFillPath(
            PathBuilder{}.AddRect(entity.GetCoverage().value()).TakePath()));
        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(PathBuilder{}.AddCubicCurve(a, 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(PathBuilder{}.AddCubicCurve(a, 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(PathBuilder{}.AddCubicCurve(a, 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(
          PathBuilder{}.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(
          PathBuilder{}.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(
          PathBuilder{}.MoveTo(a).LineTo(b).LineTo(c).Close().TakePath(),
          Cap::kButt, Join::kRound);
    }
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [367/450]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeWithTextureContents
	)

Definition at line 320 of file entity_unittests.cc.

                                              {
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  Path path = PathBuilder{}
                  .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()));
  auto contents = std::make_unique<TiledTextureContents>();
  contents->SetGeometry(Geometry::MakeStrokePath(path, 100.0));
  contents->SetTexture(bridge);
  contents->SetTileModes(Entity::TileMode::kClamp, Entity::TileMode::kClamp);
  entity.SetContents(std::move(contents));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [368/450]

impeller::testing::TEST_P	(	EntityTest	,
		SweepGradientContentsIsOpaque
	)

Definition at line 2313 of file entity_unittests.cc.

                                                  {
  RadialGradientContents contents;
  contents.SetColors({Color::CornflowerBlue()});
  ASSERT_TRUE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  ASSERT_FALSE(contents.IsOpaque());
  contents.SetColors({Color::CornflowerBlue()});
  contents.SetTileMode(Entity::TileMode::kDecal);
  ASSERT_FALSE(contents.IsOpaque());
}

◆ TEST_P() [369/450]

impeller::testing::TEST_P	(	EntityTest	,
		TextContentsCeilsGlyphScaleToDecimal
	)

Definition at line 2362 of file entity_unittests.cc.

                                                         {
  ASSERT_EQ(TextFrame::RoundScaledFontSize(0.4321111f, 12), 0.43f);
  ASSERT_EQ(TextFrame::RoundScaledFontSize(0.5321111f, 12), 0.53f);
  ASSERT_EQ(TextFrame::RoundScaledFontSize(2.1f, 12), 2.1f);
  ASSERT_EQ(TextFrame::RoundScaledFontSize(0.0f, 12), 0.0f);
  ASSERT_EQ(TextFrame::RoundScaledFontSize(100000000.0f, 12), 48.0f);
}

◆ TEST_P() [370/450]

impeller::testing::TEST_P	(	EntityTest	,
		ThreeStrokesInOnePath
	)

Definition at line 301 of file entity_unittests.cc.

                                          {
  Path path = PathBuilder{}
                  .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()));
  auto contents = std::make_unique<SolidColorContents>();
  contents->SetGeometry(Geometry::MakeStrokePath(path, 5.0));
  contents->SetColor(Color::Red());
  entity.SetContents(std::move(contents));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

◆ TEST_P() [371/450]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsIsOpaque
	)

Definition at line 2324 of file entity_unittests.cc.

                                                 {
  auto bay_bridge = CreateTextureForFixture("bay_bridge.jpg");
  TiledTextureContents contents;
  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.
  ASSERT_FALSE(contents.IsOpaque());
}

◆ TEST_P() [372/450]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsRendersWithCorrectPipeline
	)

Definition at line 20 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);
 
  TiledTextureContents contents;
  contents.SetTexture(texture);
  contents.SetGeometry(Geometry::MakeCover());
 
  auto 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);
  EXPECT_TRUE(commands[0].pipeline->GetDescriptor().GetLabel().find(
                  "TextureFill Pipeline") != std::string::npos);
 
  if (GetParam() == PlaygroundBackend::kMetal) {
    recording_pass->EncodeCommands();
  }
}

◆ TEST_P() [373/450]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsRendersWithCorrectPipelineExternalOES
	)

Definition at line 57 of file tiled_texture_contents_unittests.cc.

                                                                              {
  if (GetParam() != PlaygroundBackend::kOpenGLES) {
    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);
 
  TiledTextureContents contents;
  contents.SetTexture(texture);
  contents.SetGeometry(Geometry::MakeCover());
 
  auto 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);
  EXPECT_TRUE(commands[0].pipeline->GetDescriptor().GetLabel().find(
                  "TiledTextureFillExternal Pipeline") != std::string::npos);
}

◆ TEST_P() [374/450]

impeller::testing::TEST_P	(	EntityTest	,
		TriangleInsideASquare
	)

Definition at line 341 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);
    Path path = PathBuilder{}
                    .MoveTo(a)
                    .LineTo(b)
                    .LineTo(c)
                    .LineTo(d)
                    .Close()
                    .MoveTo(e)
                    .LineTo(f)
                    .LineTo(g)
                    .Close()
                    .TakePath();
 
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()));
    auto contents = std::make_unique<SolidColorContents>();
    contents->SetGeometry(Geometry::MakeStrokePath(path, 20.0));
    contents->SetColor(Color::Red());
    entity.SetContents(std::move(contents));
 
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [375/450]

impeller::testing::TEST_P	(	EntityTest	,
		YUVToRGBFilter
	)

Definition at line 1916 of file entity_unittests.cc.

                                   {
  if (GetParam() == PlaygroundBackend::kOpenGLES) {
    // TODO(114588) : Support YUV to RGB filter on OpenGLES backend.
    GTEST_SKIP_("YUV to RGB filter is not supported on OpenGLES backend yet.");
  }
 
  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));
}

◆ TEST_P() [376/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CalculateUVsSimple
	)

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

◆ TEST_P() [377/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CoverageWithEffectTransform
	)

Definition at line 177 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,
      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));
  }
}

◆ TEST_P() [378/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CoverageWithTexture
	)

Definition at line 156 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,
      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));
  }
}

◆ TEST_P() [379/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverage
	)

Definition at line 229 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,
      FilterContents::BlurStyle::kNormal, /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture)});
  std::shared_ptr<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::kSourceOver);
    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)));
    }
  }
}

◆ TEST_P() [380/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverageRotated
	)

Definition at line 292 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,
      FilterContents::BlurStyle::kNormal, /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture)});
  std::shared_ptr<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::kSourceOver);
    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)));
    }
  }
}

◆ TEST_P() [381/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverageTranslate
	)

Definition at line 259 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,
      FilterContents::BlurStyle::kNormal, /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture)});
  std::shared_ptr<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::kSourceOver);
    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)));
    }
  }
}

◆ TEST_P() [382/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithDestinationRect
	)

Definition at line 338 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,
      FilterContents::BlurStyle::kNormal, /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture_contents)});
  std::shared_ptr<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::kSourceOver);
    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)));
    }
  }
}

◆ TEST_P() [383/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithDestinationRectScaled
	)

Definition at line 372 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,
      FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture_contents)});
  std::shared_ptr<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::kSourceOver);
    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)));
    }
  }
}

◆ TEST_P() [384/450]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithEffectTransform
	)

Definition at line 412 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,
      FilterContents::BlurStyle::kNormal, /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture_contents)});
  contents->SetEffectTransform(effect_transform);
  std::shared_ptr<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::kSourceOver);
    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)));
    }
  }
}

◆ TEST_P() [385/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		CanEmplace
	)

Definition at line 15 of file host_buffer_unittests.cc.

                                   {
  struct Length2 {
    uint8_t pad[2];
  };
  static_assert(sizeof(Length2) == 2u);
 
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  for (size_t i = 0; i < 12500; i++) {
    auto view = buffer->Emplace(Length2{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.range, Range(i * sizeof(Length2), 2u));
  }
}

◆ TEST_P() [386/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		CanEmplaceWithAlignment
	)

Definition at line 30 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());
  ASSERT_TRUE(buffer);
 
  {
    auto view = buffer->Emplace(Length2{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.range, Range(0u, 2u));
  }
 
  {
    auto view = buffer->Emplace(Align16{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.range.offset, 16u);
    ASSERT_EQ(view.range.length, 16u);
  }
  {
    auto view = buffer->Emplace(Length2{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.range, Range(32u, 2u));
  }
 
  {
    auto view = buffer->Emplace(Align16{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.range.offset, 48u);
    ASSERT_EQ(view.range.length, 16u);
  }
}

◆ TEST_P() [387/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplaceWithProcIsAligned
	)

Definition at line 149 of file host_buffer_unittests.cc.

                                                 {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  BufferView view = buffer->Emplace(std::array<char, 21>());
  EXPECT_EQ(view.range, Range(0, 21));
 
  view = buffer->Emplace(64, 16, [](uint8_t*) {});
  EXPECT_EQ(view.range, Range(32, 64));
}

◆ TEST_P() [388/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplacingLargerThanBlockSizeCreatesOneOffBuffer
	)

Definition at line 106 of file host_buffer_unittests.cc.

                                                                        {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  // 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);
}

◆ TEST_P() [389/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplacingLargerThanBlockSizeCreatesOneOffBufferCallback
	)

Definition at line 93 of file host_buffer_unittests.cc.

                                                                {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  // 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);
}

◆ TEST_P() [390/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		HostBufferInitialState
	)

Definition at line 70 of file host_buffer_unittests.cc.

                                               {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
}

◆ TEST_P() [391/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		ResetIncrementsFrameCounter
	)

Definition at line 78 of file host_buffer_unittests.cc.

                                                    {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  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, 0u);
}

◆ TEST_P() [392/450]

impeller::testing::TEST_P	(	HostBufferTest	,
		UnusedBuffersAreDiscardedWhenResetting
	)

Definition at line 118 of file host_buffer_unittests.cc.

                                                               {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
 
  // 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 < 3; 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 < 3; 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);
}

◆ TEST_P() [393/450]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageClippedSubpassScale
	)

Definition at line 180 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}));
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(*renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(100, 200, 300, 300));
}

◆ TEST_P() [394/450]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageClippedSubpassTranslate
	)

Definition at line 143 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}));
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(*renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(200, 400, 100, 100));
}

◆ TEST_P() [395/450]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageIdentity
	)

Definition at line 111 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}));
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(*renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(100, 200, 100, 100));
}

◆ TEST_P() [396/450]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageScale
	)

Definition at line 163 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}));
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(*renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(100, 200, 300, 300));
}

◆ TEST_P() [397/450]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageSubpassScale
	)

Definition at line 200 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}));
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(*renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(300, 600, 300, 300));
}

◆ TEST_P() [398/450]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageTranslate
	)

Definition at line 126 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}));
 
  std::shared_ptr<ContentContext> renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(*renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(150, 300, 100, 100));
}

◆ TEST_P() [399/450]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanCreateRenderPassAndSubmit
	)

Definition at line 302 of file renderer_dart_unittests.cc.

                                                       {
  ASSERT_TRUE(RenderDartToPlayground("canCreateRenderPassAndSubmit"));
}

◆ TEST_P() [400/450]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanCreateShaderLibrary
	)

Definition at line 290 of file renderer_dart_unittests.cc.

                                                 {
  ASSERT_TRUE(RunDartFunction("canCreateShaderLibrary"));
}

◆ TEST_P() [401/450]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanInstantiateFlutterGPUContext
	)

These test entries correspond to Dart functions located in flutter/impeller/fixtures/dart_tests.dart

Definition at line 286 of file renderer_dart_unittests.cc.

                                                          {
  ASSERT_TRUE(RunDartFunction("instantiateDefaultContext"));
}

◆ TEST_P() [402/450]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanReflectUniformStructs
	)

Definition at line 294 of file renderer_dart_unittests.cc.

                                                   {
  ASSERT_TRUE(RunDartFunction("canReflectUniformStructs"));
}

◆ TEST_P() [403/450]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanRunDartInPlaygroundFrame
	)

Definition at line 271 of file renderer_dart_unittests.cc.

                                                      {
  SinglePassCallback callback = [&](RenderPass& pass) {
    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));
}

◆ TEST_P() [404/450]

impeller::testing::TEST_P	(	RendererDartTest	,
		UniformBindFailsForInvalidHostBufferOffset
	)

Definition at line 298 of file renderer_dart_unittests.cc.

                                                                     {
  ASSERT_TRUE(RunDartFunction("uniformBindFailsForInvalidHostBufferOffset"));
}

◆ TEST_P() [405/450]

impeller::testing::TEST_P	(	RendererTest	,
		ArrayUniforms
	)

Definition at line 997 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());
  pipeline_descriptor->SetSampleCount(SampleCount::kCount4);
  pipeline_descriptor->SetStencilAttachmentDescriptors(std::nullopt);
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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(*host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindFrameInfo(pass, 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, host_buffer->EmplaceUniform(fs_uniform));
 
    pass.Draw();
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [406/450]

impeller::testing::TEST_P	(	RendererTest	,
		BabysFirstTriangle
	)

Definition at line 123 of file renderer_unittests.cc.

                                         {
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  // Declare a shorthand for the shaders we are going to use.
  using VS = BabyVertexShader;
  using FS = BabyFragmentShader;
 
  // Create a pipeline descriptor that uses the shaders together and default
  // initializes the fixed function state.
  //
  // If the vertex shader outputs disagree with the fragment shader inputs, this
  // will be a compile time error.
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
 
  // Modify the descriptor for our environment. This is specific to our test.
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
 
  // Create a pipeline from our descriptor. This is expensive to do. So just do
  // it once.
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
 
  // Create a host side buffer to build the vertex and uniform information.
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
 
  // Specify the vertex buffer information.
  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());
 
  SinglePassCallback callback = [&](RenderPass& pass) {
    pass.SetPipeline(pipeline);
    pass.SetVertexBuffer(vertex_buffer);
 
    FS::FragInfo frag_info;
    frag_info.time = fml::TimePoint::Now().ToEpochDelta().ToSecondsF();
 
    auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
    FS::BindFragInfo(pass, host_buffer->EmplaceUniform(frag_info));
 
    return pass.Draw().ok();
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [407/450]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebuffer
	)

Definition at line 16 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());
 
  auto render_target =
      allocator->CreateOffscreenMSAA(*GetContext(), {100, 100}, 1);
  auto resolve_texture =
      render_target.GetColorAttachments().find(0u)->second.resolve_texture;
  auto& texture_vk = TextureVK::Cast(*resolve_texture);
 
  EXPECT_EQ(texture_vk.GetCachedFramebuffer(), nullptr);
  EXPECT_EQ(texture_vk.GetCachedRenderPass(), nullptr);
 
  auto buffer = GetContext()->CreateCommandBuffer();
  auto render_pass = buffer->CreateRenderPass(render_target);
 
  EXPECT_NE(texture_vk.GetCachedFramebuffer(), nullptr);
  EXPECT_NE(texture_vk.GetCachedRenderPass(), nullptr);
 
  render_pass->EncodeCommands();
  GetContext()->GetCommandQueue()->Submit({buffer});
 
  // 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());
}

◆ TEST_P() [408/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanBlitTextureToBuffer
	)

Definition at line 613 of file renderer_unittests.cc.

                                             {
  if (GetBackend() == PlaygroundBackend::kOpenGLES) {
    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());
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
  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);
  const std::unique_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 host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  Renderer::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");
 
      if (render_target.GetColorAttachments().empty()) {
        return false;
      }
 
      // Blit `bridge` to the top left corner of the texture.
      pass->AddCopy(bridge, device_buffer);
      pass->EncodeCommands(context->GetResourceAllocator());
 
      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, host_buffer->EmplaceUniform(frame_info));
 
        FS::FragInfo frag_info;
        frag_info.lod = 0;
        FS::BindFragInfo(*pass, host_buffer->EmplaceUniform(frag_info));
 
        const std::unique_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.range.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;
      }
    }
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [409/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanBlitTextureToTexture
	)

Definition at line 498 of file renderer_unittests.cc.

                                              {
  if (GetBackend() == PlaygroundBackend::kOpenGLES) {
    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());
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
  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);
  const std::unique_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 host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  Renderer::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");
 
      if (render_target.GetColorAttachments().empty()) {
        return false;
      }
 
      // Blit `bridge` to the top left corner of the texture.
      pass->AddCopy(bridge, texture);
 
      if (!pass->EncodeCommands(context->GetResourceAllocator())) {
        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, host_buffer->EmplaceUniform(frame_info));
 
        FS::FragInfo frag_info;
        frag_info.lod = 0;
        FS::BindFragInfo(*pass, 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;
    }
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [410/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanCreateBoxPrimitive
	)

Definition at line 54 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());
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
 
  // 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);
  const std::unique_ptr<const Sampler>& sampler =
      context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  SinglePassCallback callback = [&](RenderPass& pass) {
    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
    static bool wireframe;
    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, 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, host_buffer->EmplaceUniform(frame_info));
    FS::BindContents1(pass, boston, sampler);
    FS::BindContents2(pass, bridge, sampler);
 
    host_buffer->Reset();
    return pass.Draw().ok();
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [411/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanGenerateMipmaps
	)

Definition at line 747 of file renderer_unittests.cc.

                                         {
  if (GetBackend() == PlaygroundBackend::kOpenGLES) {
    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());
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
  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 host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  Renderer::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;
 
    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(context->GetResourceAllocator());
    }
 
    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, host_buffer->EmplaceUniform(frame_info));
 
        FS::FragInfo frag_info;
        frag_info.lod = lod;
        FS::BindFragInfo(*pass, 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];
        const std::unique_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;
    }
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [412/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanLookupRenderTargetProperties
	)

Definition at line 1341 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();
}

◆ TEST_P() [413/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderInstanced
	)

Definition at line 441 of file renderer_unittests.cc.

                                         {
  if (GetParam() == PlaygroundBackend::kOpenGLES) {
    GTEST_SKIP_("Instancing is not supported on OpenGL.");
  }
  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}},
  });
 
  ASSERT_NE(GetContext(), nullptr);
  auto pipeline =
      GetContext()
          ->GetPipelineLibrary()
          ->GetPipeline(PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(
                            *GetContext())
                            ->SetSampleCount(SampleCount::kCount4)
                            .SetStencilAttachmentDescriptors(std::nullopt))
 
          .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 host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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, host_buffer->EmplaceUniform(frame_info));
    VS::BindInstanceInfo(pass, host_buffer->EmplaceStorageBuffer(instances));
    pass.SetVertexBuffer(builder.CreateVertexBuffer(*host_buffer));
 
    pass.SetInstanceCount(kInstancesCount);
    pass.Draw();
 
    host_buffer->Reset();
    return true;
  }));
}

◆ TEST_P() [414/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderMultiplePrimitives
	)

Definition at line 265 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());
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
  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);
  const std::unique_ptr<const Sampler>& sampler =
      context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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, 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, host_buffer->EmplaceUniform(uniforms));
        if (!pass.Draw().ok()) {
          return false;
        }
      }
    }
 
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [415/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderPerspectiveCube
	)

Definition at line 176 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());
  desc->SetCullMode(CullMode::kBackFace);
  desc->SetWindingOrder(WindingOrder::kCounterClockwise);
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(pipeline);
 
  struct Cube {
    VS::PerVertexData vertices[8] = {
        // -Z
        {{-1, -1, -1}, Color::Red()},
        {{1, -1, -1}, Color::Yellow()},
        {{1, 1, -1}, Color::Green()},
        {{-1, 1, -1}, Color::Blue()},
        // +Z
        {{-1, -1, 1}, Color::Green()},
        {{1, -1, 1}, Color::Blue()},
        {{1, 1, 1}, Color::Red()},
        {{-1, 1, 1}, 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;
 
  VertexBuffer vertex_buffer;
  {
    auto device_buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
        reinterpret_cast<uint8_t*>(&cube), sizeof(cube));
    vertex_buffer.vertex_buffer = {
        .buffer = device_buffer,
        .range = Range(offsetof(Cube, vertices), sizeof(Cube::vertices))};
    vertex_buffer.index_buffer = {
        .buffer = device_buffer,
        .range = Range(offsetof(Cube, indices), sizeof(Cube::indices))};
    vertex_buffer.vertex_count = 36;
    vertex_buffer.index_type = IndexType::k16bit;
  }
 
  const std::unique_ptr<const Sampler>& sampler =
      context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  Vector3 euler_angles;
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  SinglePassCallback callback = [&](RenderPass& pass) {
    static Degrees fov_y(60);
    static Scalar distance = 10;
 
    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);
    pass.SetVertexBuffer(vertex_buffer);
 
    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, host_buffer->EmplaceUniform(uniforms));
 
    host_buffer->Reset();
    return pass.Draw().ok();
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [416/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderToTexture
	)

Definition at line 338 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 host_buffer = HostBuffer::Create(context->GetResourceAllocator());
 
  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);
  const std::unique_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, 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, host_buffer->EmplaceUniform(uniforms));
  ASSERT_TRUE(r2t_pass->Draw().ok());
  ASSERT_TRUE(r2t_pass->EncodeCommands());
}

◆ TEST_P() [417/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanSepiaToneThenSwizzleWithSubpasses
	)

Definition at line 1489 of file renderer_unittests.cc.

                                                           {
  // The GLES framebuffer fetch implementation currently does not support this.
  // TODO(chinmaygarde): revisit after the GLES framebuffer fetch capabilities
  // are clarified.
  if (GetParam() == PlaygroundBackend::kOpenGLES) {
    GTEST_SKIP_("Not supported on GLES.");
  }
 
  // 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>(context);
  auto swizzle_pipeline = CreateDefaultPipeline<SwizzleVS, SwizzleFS>(context);
  auto sepia_pipeline = CreateDefaultPipeline<SepiaVS, SepiaFS>(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);
 
  SinglePassCallback callback = [&](RenderPass& pass) {
    auto buffer = HostBuffer::Create(context->GetResourceAllocator());
 
    // 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;
      }
    }
 
    // 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, buffer->EmplaceUniform(uniforms));
      if (!pass.Draw().ok()) {
        return false;
      }
    }
 
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [418/450]

impeller::testing::TEST_P	(	RendererTest	,
		CanSepiaToneWithSubpasses
	)

Definition at line 1394 of file renderer_unittests.cc.

                                                {
  // The GLES framebuffer fetch implementation currently does not support this.
  // TODO(chinmaygarde): revisit after the GLES framebuffer fetch capabilities
  // are clarified.
  if (GetParam() == PlaygroundBackend::kOpenGLES) {
    GTEST_SKIP_("Not supported on GLES.");
  }
 
  // 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>(context);
  auto sepia_pipeline = CreateDefaultPipeline<SepiaVS, SepiaFS>(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);
 
  SinglePassCallback callback = [&](RenderPass& pass) {
    auto buffer = HostBuffer::Create(context->GetResourceAllocator());
 
    // 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);
}

◆ TEST_P() [419/450]

impeller::testing::TEST_P	(	RendererTest	,
		DefaultIndexBehavior
	)

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

◆ TEST_P() [420/450]

impeller::testing::TEST_P	(	RendererTest	,
		DefaultIndexSize
	)

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

◆ TEST_P() [421/450]

impeller::testing::TEST_P	(	RendererTest	,
		InactiveUniforms
	)

Definition at line 1054 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());
  pipeline_descriptor->SetSampleCount(SampleCount::kCount4);
  pipeline_descriptor->SetStencilAttachmentDescriptors(std::nullopt);
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  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(*host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindFrameInfo(pass, host_buffer->EmplaceUniform(frame_info));
 
    FS::FragInfo fs_uniform = {.unused_color = Color::Red(),
                               .color = Color::Green()};
    FS::BindFragInfo(pass, host_buffer->EmplaceUniform(fs_uniform));
 
    pass.Draw().ok();
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [422/450]

impeller::testing::TEST_P	(	RendererTest	,
		Planet
	)

Definition at line 931 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());
  pipeline_descriptor->SetSampleCount(SampleCount::kCount4);
  pipeline_descriptor->SetStencilAttachmentDescriptors(std::nullopt);
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
 
  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();
 
    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(*host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp = pass.GetOrthographicTransform();
    VS::BindFrameInfo(pass, 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, host_buffer->EmplaceUniform(fs_uniform));
 
    pass.Draw().ok();
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [423/450]

impeller::testing::TEST_P	(	RendererTest	,
		RenderTargetCreateOffscreenMSAASetsDefaultDepthStencilFormat
	)

Definition at line 1361 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());
}

◆ TEST_P() [424/450]

impeller::testing::TEST_P	(	RendererTest	,
		StencilMask
	)

Definition at line 1189 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);
  const std::unique_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 host_buffer = HostBuffer::Create(context->GetResourceAllocator());
  Renderer::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");
      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, 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, 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;
    }
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [425/450]

impeller::testing::TEST_P	(	RendererTest	,
		TheImpeller
	)

Definition at line 869 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());
  pipeline_descriptor->SetSampleCount(SampleCount::kCount4);
  pipeline_descriptor->SetStencilAttachmentDescriptors(std::nullopt);
  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;
  const std::unique_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"});
  const std::unique_ptr<const Sampler>& cube_map_sampler =
      context->GetSamplerLibrary()->GetSampler({});
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator());
 
  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(*host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp = pass.GetOrthographicTransform();
    VS::BindFrameInfo(pass, host_buffer->EmplaceUniform(frame_info));
 
    FS::FragInfo fs_uniform;
    fs_uniform.texture_size = Point(size);
    fs_uniform.time = GetSecondsElapsed();
    FS::BindFragInfo(pass, host_buffer->EmplaceUniform(fs_uniform));
    FS::BindBlueNoise(pass, blue_noise, noise_sampler);
    FS::BindCubeMap(pass, cube_map, cube_map_sampler);
 
    pass.Draw().ok();
    host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

◆ TEST_P() [426/450]

impeller::testing::TEST_P	(	RendererTest	,
		VertexBufferBuilder
	)

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

◆ TEST_P() [427/450]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachedTextureGetsNewAttachmentConfig
	)

Definition at line 90 of file render_target_cache_unittests.cc.

                                                                    {
  auto render_target_cache =
      RenderTargetCache(GetContext()->GetResourceAllocator());
 
  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();
 
  auto color1 = target1.GetColorAttachments().find(0)->second;
  auto color2 = target2.GetColorAttachments().find(0)->second;
  // 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());
}

◆ TEST_P() [428/450]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachesUsedTexturesAcrossFrames
	)

Definition at line 51 of file render_target_cache_unittests.cc.

                                                              {
  auto render_target_cache =
      RenderTargetCache(GetContext()->GetResourceAllocator());
 
  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() [429/450]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CreateWithEmptySize
	)

Definition at line 115 of file render_target_cache_unittests.cc.

                                                   {
  auto render_target_cache =
      RenderTargetCache(GetContext()->GetResourceAllocator());
 
  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());
  }
}

◆ TEST_P() [430/450]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		DoesNotPersistFailedAllocations
	)

Definition at line 75 of file render_target_cache_unittests.cc.

                                                               {
  ScopedValidationDisable disable;
  auto allocator = std::make_shared<TestAllocator>();
  auto render_target_cache = RenderTargetCache(allocator);
 
  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);
}

◆ TEST_P() [431/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanCreatePipelineFromRuntimeStage
	)

Definition at line 314 of file runtime_stage_unittests.cc.

                                                            {
  auto stages = OpenAssetAsRuntimeStage("ink_sparkle.frag.iplr");
  auto stage = stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
 
  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);
}

◆ TEST_P() [432/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniforms
	)

Definition at line 55 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);
  auto stage = stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
 
  ASSERT_TRUE(stage->IsValid());
  switch (GetBackend()) {
    case PlaygroundBackend::kMetal:
      [[fallthrough]];
    case PlaygroundBackend::kOpenGLES: {
      ASSERT_EQ(stage->GetUniforms().size(), 17u);
      {
        auto uni = stage->GetUniform("u_color");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 4u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 0u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_alpha");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 1u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_sparkle_color");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 4u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 2u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_sparkle_alpha");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 3u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_blur");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 4u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_radius_scale");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 6u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_max_radius");
        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);
      }
      {
        auto uni = stage->GetUniform("u_resolution_scale");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 8u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_noise_scale");
        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);
      }
      {
        auto uni = stage->GetUniform("u_noise_phase");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 10u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
 
      {
        auto uni = stage->GetUniform("u_circle1");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 11u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_circle2");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 12u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_circle3");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 13u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_rotation1");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 14u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_rotation2");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 15u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        auto uni = stage->GetUniform("u_rotation3");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 16u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      break;
    }
    case PlaygroundBackend::kVulkan: {
      EXPECT_EQ(stage->GetUniforms().size(), 1u);
      auto uni = stage->GetUniform(RuntimeStage::kVulkanUBOName);
      ASSERT_TRUE(uni);
      EXPECT_EQ(uni->type, RuntimeUniformType::kStruct);
      EXPECT_EQ(uni->struct_float_count, 32u);
 
      // There are 36 4 byte chunks in the UBO: 32 for the 32 floats, and 4 for
      // padding. Initialize a vector as if they'll all be floats, then manually
      // set the few padding bytes. If the shader changes, the padding locations
      // will change as well. For example, if `u_alpha` was moved to the end,
      // three bytes of padding could potentially be dropped - or if some of the
      // scalar floats were changed to vec2 or vec4s, or if any vec3s are
      // introduced.
      // This means 36 * 4 = 144 bytes total.
 
      EXPECT_EQ(uni->GetSize(), 144u);
      std::vector<uint8_t> layout(uni->GetSize() / sizeof(float), 1);
      layout[5] = 0;
      layout[6] = 0;
      layout[7] = 0;
      layout[23] = 0;
 
      EXPECT_THAT(uni->struct_layout, ::testing::ElementsAreArray(layout));
      break;
    }
  }
}

◆ TEST_P() [433/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniformsSamplerAfterUBO
	)

Definition at line 254 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);
  auto stage = stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
 
  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);
}

◆ TEST_P() [434/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniformsSamplerBeforeUBO
	)

Definition at line 229 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);
  auto stage = stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
 
  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);
}

◆ TEST_P() [435/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadValidBlob
	)

Definition at line 29 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);
  auto stage = stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(stage->IsValid());
  ASSERT_EQ(stage->GetShaderStage(), RuntimeShaderStage::kFragment);
}

◆ TEST_P() [436/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanRegisterStage
	)

Definition at line 279 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);
  auto stage = stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
  ASSERT_TRUE(stage->IsValid());
  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);
  }
}

◆ TEST_P() [437/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanRejectInvalidBlob
	)

Definition at line 40 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(fixture->GetSize(), false));
  // Not meant to be secure. Just reject obviously bad blobs using magic
  // numbers.
  ::memset(junk_allocation->GetBuffer(), 127, junk_allocation->GetLength());
  auto stages = RuntimeStage::DecodeRuntimeStages(
      CreateMappingFromAllocation(junk_allocation));
  ASSERT_FALSE(stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())]);
}

◆ TEST_P() [438/450]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		ContainsExpectedShaderTypes
	)

Definition at line 357 of file runtime_stage_unittests.cc.

                                                      {
  auto stages = OpenAssetAsRuntimeStage("ink_sparkle.frag.iplr");
  // Right now, SkSL gets implicitly bundled regardless of what the build rule
  // for this test requested. After
  // https://github.com/flutter/flutter/issues/138919, this may require a build
  // rule change or a new test.
  EXPECT_TRUE(stages[RuntimeStageBackend::kSkSL]);
 
  EXPECT_TRUE(stages[RuntimeStageBackend::kOpenGLES]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kMetal]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kVulkan]);
}

◆ TEST_P() [439/450]

impeller::testing::TEST_P	(	TypographerTest	,
		CanConvertTextBlob
	)

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

◆ TEST_P() [440/450]

impeller::testing::TEST_P	(	TypographerTest	,
		CanCreateGlyphAtlas
	)

Definition at line 83 of file typographer_unittests.cc.

                                             {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, 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());
}

◆ TEST_P() [441/450]

impeller::testing::TEST_P	(	TypographerTest	,
		CanCreateRenderContext
	)

Definition at line 78 of file typographer_unittests.cc.

                                                {
  auto context = TypographerContextSkia::Make();
  ASSERT_TRUE(context && context->IsValid());
}

◆ TEST_P() [442/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasIsRecycledIfUnchanged
	)

Definition at line 179 of file typographer_unittests.cc.

                                                         {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, 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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, atlas_context,
                       *MakeTextFrameFromTextBlobSkia(blob));
  ASSERT_EQ(atlas, next_atlas);
  ASSERT_EQ(atlas_context->GetGlyphAtlas(), atlas);
}

◆ TEST_P() [443/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasTextureIsRecycledIfUnchanged
	)

Definition at line 253 of file typographer_unittests.cc.

                                                                {
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, 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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, 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);
}

◆ TEST_P() [444/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasTextureWillGrowTilMaxTextureSize
	)

Definition at line 419 of file typographer_unittests.cc.

                                                                    {
  if (GetBackend() == PlaygroundBackend::kOpenGLES) {
    GTEST_SKIP() << "Atlas growth isn't supported for OpenGLES currently.";
  }
 
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, atlas_context,
                       *MakeTextFrameFromTextBlobSkia(blob));
  // Continually append new glyphs until the glyph size grows to the maximum.
  // Note that the sizes here are more or less experimentally determined, but
  // the important expectation is that the atlas size will shrink again after
  // growing to the maximum size.
  constexpr ISize expected_sizes[13] = {
      {4096, 4096},   //
      {4096, 4096},   //
      {4096, 8192},   //
      {4096, 8192},   //
      {4096, 8192},   //
      {4096, 8192},   //
      {4096, 16384},  //
      {4096, 16384},  //
      {4096, 16384},  //
      {4096, 16384},  //
      {4096, 16384},  //
      {4096, 16384},  //
      {4096, 4096}    // Shrinks!
  };
 
  for (int i = 0; i < 13; i++) {
    SkFont sk_font = flutter::testing::CreateTestFontOfSize(50 + i);
    auto blob = SkTextBlob::MakeFromString("A", sk_font);
 
    atlas =
        CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                         GlyphAtlas::Type::kAlphaBitmap, 50 + i, atlas_context,
                         *MakeTextFrameFromTextBlobSkia(blob));
    ASSERT_TRUE(!!atlas);
    EXPECT_EQ(atlas->GetTexture()->GetTextureDescriptor().size,
              expected_sizes[i]);
  }
}

◆ TEST_P() [445/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasWithLotsOfdUniqueGlyphSize
	)

Definition at line 206 of file typographer_unittests.cc.

                                                              {
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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);
 
  FontGlyphMap font_glyph_map;
  size_t size_count = 8;
  for (size_t index = 0; index < size_count; index += 1) {
    MakeTextFrameFromTextBlobSkia(blob)->CollectUniqueFontGlyphPairs(
        font_glyph_map, 0.6 * index, {0, 0}, {});
  };
  auto atlas =
      context->CreateGlyphAtlas(*GetContext(), GlyphAtlas::Type::kAlphaBitmap,
                                *host_buffer, atlas_context, font_glyph_map);
  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);
}

◆ TEST_P() [446/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasWithOddUniqueGlyphSize
	)

Definition at line 159 of file typographer_unittests.cc.

                                                          {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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(), *host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, 1.0f, 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);
}

◆ TEST_P() [447/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphColorIsIgnoredForNonEmojiFonts
	)

Definition at line 324 of file typographer_unittests.cc.

                                                             {
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
  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));
  auto properties = {
      GlyphProperties{},
      GlyphProperties{},
  };
 
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                       GlyphAtlas::Type::kColorBitmap, 1.0f, atlas_context,
                       {frame, frame_2}, properties);
 
  EXPECT_EQ(next_atlas->GetGlyphCount(), 1u);
}

◆ TEST_P() [448/450]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphColorIsPartOfCacheKey
	)

Definition at line 290 of file typographer_unittests.cc.

                                                    {
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
#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));
  auto properties = {
      GlyphProperties{.color = Color::Red()},
      GlyphProperties{.color = Color::Blue()},
  };
 
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                       GlyphAtlas::Type::kColorBitmap, 1.0f, atlas_context,
                       {frame, frame_2}, properties);
 
  EXPECT_EQ(next_atlas->GetGlyphCount(), 2u);
}

◆ TEST_P() [449/450]

impeller::testing::TEST_P	(	TypographerTest	,
		LazyAtlasTracksColor
	)

Definition at line 120 of file typographer_unittests.cc.

                                              {
  auto host_buffer = HostBuffer::Create(GetContext()->GetResourceAllocator());
#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, 1.0f, {0, 0}, {});
 
  frame = MakeTextFrameFromTextBlobSkia(
      SkTextBlob::MakeFromString("😀 ", emoji_font));
 
  ASSERT_TRUE(frame->GetAtlasType() == GlyphAtlas::Type::kColorBitmap);
 
  lazy_atlas.AddTextFrame(*frame, 1.0f, {0, 0}, {});
 
  // Creates different atlases for color and red bitmap.
  auto color_atlas = lazy_atlas.CreateOrGetGlyphAtlas(
      *GetContext(), *host_buffer, GlyphAtlas::Type::kColorBitmap);
 
  auto bitmap_atlas = lazy_atlas.CreateOrGetGlyphAtlas(
      *GetContext(), *host_buffer, GlyphAtlas::Type::kAlphaBitmap);
 
  ASSERT_FALSE(color_atlas == bitmap_atlas);
}

◆ TEST_P() [450/450]

impeller::testing::TEST_P	(	TypographerTest	,
		RectanglePackerAddsNonoverlapingRectangles
	)

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

◆ toColor()

flutter::DlColor impeller::testing::toColor ( const float * components )

Definition at line 41 of file dl_unittests.cc.

                                                {
  return flutter::DlColor(Color::ToIColor(
      Color(components[0], components[1], components[2], components[3])));
}

Variable Documentation

◆ g_extensions

std::vector<const unsigned char*> impeller::testing::g_extensions

static

Definition at line 24 of file mock_gles.cc.

◆ g_mock_gles

std::weak_ptr<MockGLES> impeller::testing::g_mock_gles

static

Definition at line 20 of file mock_gles.cc.

◆ g_resolver

ProcTableGLES::Resolver impeller::testing::g_resolver

static

Definition at line 22 of file mock_gles.cc.

◆ g_test_lock

std::mutex impeller::testing::g_test_lock

static

Definition at line 18 of file mock_gles.cc.

◆ g_version

const unsigned char* impeller::testing::g_version

static

Definition at line 26 of file mock_gles.cc.

◆ golden_cubic_and_quad_points

std::vector<Point> impeller::testing::golden_cubic_and_quad_points

Definition at line 16 of file golden_paths.h.

◆ kExtensions

auto const impeller::testing::kExtensions

Initial value:

= std::vector<const unsigned char*>{
    (unsigned char*)"GL_KHR_debug"  
}

Definition at line 46 of file mock_gles.cc.

◆ kFontFixture

constexpr std::string_view impeller::testing::kFontFixture

staticconstexpr

Initial value:

=
 
    "NotoColorEmoji.ttf"

Definition at line 728 of file aiks_unittests.cc.

◆ kMockResolverGLES

const ProcTableGLES::Resolver impeller::testing::kMockResolverGLES

Initial value:

= [](const char* name) {
  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, "glGetQueryObjectui64vEXT") == 0) {
    return reinterpret_cast<void*>(mockGetQueryObjectui64vEXT);
  } else if (strcmp(name, "glGetQueryObjectuivEXT") == 0) {
    return reinterpret_cast<void*>(mockGetQueryObjectuivEXT);
  } else {
    return reinterpret_cast<void*>(&doNothing);
  }
}

Definition at line 180 of file mock_gles.cc.

◆ kMockShadingLanguageVersion

const auto impeller::testing::kMockShadingLanguageVersion = (unsigned char*)"GLSL ES 1.0"

Definition at line 45 of file mock_gles.cc.

◆ kMockVendor

auto const impeller::testing::kMockVendor = (unsigned char*)"MockGLES"

Definition at line 44 of file mock_gles.cc.

◆ kPaintVariations

const std::map<std::string, MaskBlurTestConfig> impeller::testing::kPaintVariations

static

Definition at line 378 of file aiks_blur_unittests.cc.

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AiksCanvasTest

◆ AiksTest

◆ BlitPassTest

◆ ComputeTest

◆ DeviceBufferTest

◆ DisplayListTest

◆ DriverInfoVKTest

◆ EntityPassTargetTest

◆ EntityTest

◆ HostBufferTest

◆ RendererTest

◆ RenderTargetCacheTest

◆ RuntimeStageTest

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

◆ CanRenderConicalGradientWithDithering()

◆ CanRenderLinearGradientWithDithering()

◆ CanRenderRadialGradientWithDithering()

◆ CanRenderSweepGradientWithDithering()

◆ CAPABILITY_TEST() [1/9]

◆ CAPABILITY_TEST() [2/9]

◆ CAPABILITY_TEST() [3/9]

◆ CAPABILITY_TEST() [4/9]

◆ CAPABILITY_TEST() [5/9]

◆ CAPABILITY_TEST() [6/9]

◆ CAPABILITY_TEST() [7/9]

◆ CAPABILITY_TEST() [8/9]

◆ CAPABILITY_TEST() [9/9]

◆ CompareFunctionUI()

◆ CreateDefaultPipeline()

◆ CreateGlyphAtlas() [1/2]

◆ CreateGlyphAtlas() [2/2]

◆ CreateMappingFromString()

◆ CreatePassWithRectPath()

◆ CreateStringFromMapping()

◆ CreateSurface()

◆ CreateTestYUVTextures()

◆ doNothing()

◆ flip_lr()

◆ flip_lrtb()

◆ flip_tb()

◆ GetBlendModeSelection()

◆ GetCoverageOfFirstEntity()

◆ GetMockVulkanFunctions()

◆ INSTANTIATE_COMPUTE_SUITE()

◆ INSTANTIATE_PLAYGROUND_SUITE() [1/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [2/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [3/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [4/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [5/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [6/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [7/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [8/9]

◆ INSTANTIATE_PLAYGROUND_SUITE() [9/9]

◆ INSTANTIATE_VULKAN_PLAYGROUND_SUITE()

◆ InstantiateTestShaderLibrary()

◆ MaskBlurVariantTest()

◆ mockBeginQueryEXT()

◆ mockDeleteQueriesEXT()

◆ mockEndQueryEXT()

◆ mockGenQueriesEXT()

◆ mockGetError()

◆ mockGetIntegerv()

◆ mockGetQueryObjectui64vEXT()

◆ mockGetQueryObjectuivEXT()

◆ mockGetString()

◆ mockGetStringi()

◆ mockPopDebugGroupKHR()

◆ mockPushDebugGroupKHR()

◆ RecordGLCall()