Classes
struct	Foo

struct	RWFoo

struct	CVTest

struct	BlendModeSelection

struct	MaskBlurTestConfig

struct	TextRenderOptions

class	BlendFilterContentsTest

class	GaussianBlurFilterContentsTest

class	MatrixFilterContentsTest

class	MockIdleWaiter

class	FailingAllocator

class	FlushTestDeviceBuffer

class	FlushTestAllocator

class	FlushTestContentContext

class	TestAllocator

struct	ColorBlendTestData

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

class	GoldenTests

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

class	MetalScreenshotter

class	Screenshot

class	Screenshotter

class	VulkanScreenshotter

class	WorkingDirectory

class	RendererDartTest

class	CompareFunctionUIData

class	MockPathVertexWriter

class	MockSegmentReceiver

Typedefs
using	AiksTest = AiksPlayground

using	DisplayListTest = DlPlayground

using	HostBufferTest = EntityPlayground

using	TextContentsTest = PlaygroundTest

using	EntityTest = EntityPlayground

using	EntityPassTargetTest = EntityPlayground

using	RenderTargetCacheTest = EntityPlayground

using	SaveLayerUtilsTest = ::testing::Test

using	DlPathReceiverMock = flutter::testing::DlPathReceiverMock

using	AllocatorMTLTest = PlaygroundTest

using	ContextMTLTest = PlaygroundTest

using	SwapchainTransientsMTLTest = PlaygroundTest

using	DriverInfoVKTest = PlaygroundTest

using	PipelineCacheDataVKPlaygroundTest = PlaygroundTest

using	RendererTest = PlaygroundTest

using	BlitPassTest = AiksTest

using	ComputeTest = ComputePlaygroundTest

using	DeviceBufferTest = Playground

using	RuntimeStageTest = RuntimeStagePlayground

using	TypographerTest = PlaygroundTest

Functions
	TEST (AllocationSizeTest, CanCreateTypedAllocations)

	TEST (AllocationSizeTest, CanCreateTypedAllocationsWithLiterals)

	TEST (AllocationSizeTest, CanConvert)

	TEST (AllocationSizeTest, ConversionsAreNonTruncating)

	TEST (AllocationSizeTest, CanGetFloatValues)

	TEST (AllocationSizeTest, RelationalOperatorsAreFunctional)

	TEST (AllocationSizeTest, CanCast)

	TEST (AllocationSizeTest, CanPerformSimpleArithmetic)

	TEST (AllocationSizeTest, CanConstructWithArith)

	TEST (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 (AllocatorTest, RangeTest)

	TEST (BufferViewTest, Empty)

	TEST (BufferViewTest, TakeRaw)

	TEST_P (AiksTest, DrawAtlasNoColor)

	TEST_P (AiksTest, DrawAtlasWithColorAdvanced)

	TEST_P (AiksTest, DrawAtlasWithColorSimple)

	TEST_P (AiksTest, DrawAtlasWithOpacity)

	TEST_P (AiksTest, DrawAtlasNoColorFullSize)

	TEST_P (AiksTest, DrawAtlasAdvancedAndTransform)

	TEST_P (AiksTest, DrawAtlasWithColorAdvancedAndTransform)

	TEST_P (AiksTest, DrawAtlasPlusWideGamut)

	TEST_P (AiksTest, DlAtlasGeometryNoBlendRenamed)

	TEST_P (AiksTest, DlAtlasGeometryBlend)

	TEST_P (AiksTest, DlAtlasGeometryColorButNoBlend)

	TEST_P (AiksTest, DlAtlasGeometrySkip)

	TEST_P (AiksTest, DrawImageRectWithBlendColorFilter)

	TEST_P (AiksTest, DrawImageRectWithMatrixColorFilter)

	TEST_P (AiksTest, 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, DrawImageRectSrcOutsideBounds)

	TEST_P (AiksTest, CanRenderSimpleClips)

	TEST_P (AiksTest, CanSaveLayerStandalone)

	TEST_P (AiksTest, CanRenderDifferentShapesWithSameColorSource)

	TEST_P (AiksTest, CanRenderRoundedRectWithNonUniformRadii)

	TEST_P (AiksTest, CanDrawPaint)

	TEST_P (AiksTest, CanDrawPaintMultipleTimes)

	TEST_P (AiksTest, StrokedRectsRenderCorrectly)

	TEST_P (AiksTest, FilledCirclesRenderCorrectly)

	TEST_P (AiksTest, StrokedCirclesRenderCorrectly)

	TEST_P (AiksTest, FilledEllipsesRenderCorrectly)

	TEST_P (AiksTest, FilledArcsRenderCorrectly)

	TEST_P (AiksTest, FilledArcsRenderCorrectlyWithCenter)

	TEST_P (AiksTest, NonSquareFilledArcsRenderCorrectly)

	TEST_P (AiksTest, NonSquareFilledArcsRenderCorrectlyWithCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithButtEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithSquareEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithRoundEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithBevelJoinsAndCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithMiterJoinsAndCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithRoundJoinsAndCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithSquareAndButtEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithSquareAndButtAndRoundEnds)

	TEST_P (AiksTest, StrokedArcsCoverFullArcWithButtEnds)

	TEST_P (AiksTest, FilledRoundRectsRenderCorrectly)

	TEST_P (AiksTest, SolidColorCirclesOvalsRRectsMaskBlurCorrectly)

	TEST_P (AiksTest, CanRenderClippedBackdropFilter)

	TEST_P (AiksTest, CanDrawPerspectiveTransformWithClips)

	TEST_P (AiksTest, ImageColorSourceEffectTransform)

	TEST_P (AiksTest, SubpassWithClearColorOptimization)

	TEST_P (AiksTest, MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen)

	TEST_P (AiksTest, MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen)

	TEST_P (AiksTest, ClearColorOptimizationWhenSubpassIsBiggerThanParentPass)

	TEST_P (AiksTest, EmptySaveLayerIgnoresPaint)

	TEST_P (AiksTest, EmptySaveLayerRendersWithClear)

	TEST_P (AiksTest, CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated)

	TEST_P (AiksTest, FormatWideGamut)

	TEST_P (AiksTest, FormatSRGB)

	TEST_P (AiksTest, CoordinateConversionsAreCorrect)

	TEST_P (AiksTest, CanPerformFullScreenMSAA)

	TEST_P (AiksTest, CanPerformSkew)

	TEST_P (AiksTest, CanPerformSaveLayerWithBounds)

	TEST_P (AiksTest, FilledRoundRectPathsRenderCorrectly)

	TEST_P (AiksTest, CoverageOriginShouldBeAccountedForInSubpasses)

	TEST_P (AiksTest, SaveLayerDrawsBehindSubsequentEntities)

	TEST_P (AiksTest, SiblingSaveLayerBoundsAreRespected)

	TEST_P (AiksTest, CanRenderClippedLayers)

	TEST_P (AiksTest, SaveLayerFiltersScaleWithTransform)

	TEST_P (AiksTest, FastEllipticalRRectMaskBlursRenderCorrectly)

	TEST_P (AiksTest, PipelineBlendSingleParameter)

	TEST_P (AiksTest, MassiveScalingMatrixImageFilter)

	TEST_P (AiksTest, NoDimplesInRRectPath)

	TEST_P (AiksTest, BackdropFilterOverUnclosedClip)

static BlendModeSelection	GetBlendModeSelection ()

	TEST_P (AiksTest, CanRenderAdvancedBlendColorFilterWithSaveLayer)

	TEST_P (AiksTest, BlendModeShouldCoverWholeScreen)

	TEST_P (AiksTest, CanDrawPaintWithAdvancedBlend)

	TEST_P (AiksTest, DrawPaintWithAdvancedBlendOverFilter)

	TEST_P (AiksTest, DrawAdvancedBlendPartlyOffscreen)

	TEST_P (AiksTest, PaintBlendModeIsRespected)

	TEST_P (AiksTest, ColorFilterBlend)

	TEST_P (AiksTest, ColorFilterAdvancedBlend)

	TEST_P (AiksTest, ColorFilterAdvancedBlendNoFbFetch)

	TEST_P (AiksTest, BlendModePlusAlphaWideGamut)

	TEST_P (AiksTest, BlendModePlusAlphaColorFilterWideGamut)

	TEST_P (AiksTest, ForegroundBlendSubpassCollapseOptimization)

	TEST_P (AiksTest, ClearBlend)

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

	TEST_P (AiksTest, CanDrawPaintMultipleTimesInteractive)

	TEST_P (AiksTest, ForegroundPipelineBlendAppliesTransformCorrectly)

	TEST_P (AiksTest, ForegroundAdvancedBlendAppliesTransformCorrectly)

	TEST_P (AiksTest, FramebufferAdvancedBlendCoverage)

	TEST_P (AiksTest, ColorWheel)

	TEST_P (AiksTest, DestructiveBlendColorFilterFloodsClip)

	TEST_P (AiksTest, AdvancedBlendColorFilterWithDestinationOpacity)

	TEST_P (AiksTest, EmulatedAdvancedBlendRestore)

	TEST_P (AiksTest, SolidColorOvalsMaskBlurTinySigma)

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

	TEST_P (AiksTest, GradientOvalStrokeMaskBlur)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurSigmaZero)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurOuter)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurInner)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurSolid)

	TEST_P (AiksTest, SolidColorCircleMaskBlurTinySigma)

	TEST_P (AiksTest, CanRenderMaskBlurHugeSigma)

	TEST_P (AiksTest, CanRenderForegroundBlendWithMaskBlur)

	TEST_P (AiksTest, CanRenderForegroundAdvancedBlendWithMaskBlur)

	TEST_P (AiksTest, CanRenderBackdropBlurInteractive)

	TEST_P (AiksTest, CanRenderBackdropBlur)

	TEST_P (AiksTest, CanRenderBackdropBlurWithSingleBackdropId)

	TEST_P (AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropId)

	TEST_P (AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropIdAndDistinctFilters)

	TEST_P (AiksTest, CanRenderBackdropBlurHugeSigma)

	TEST_P (AiksTest, CanRenderClippedBlur)

	TEST_P (AiksTest, ClippedBlurFilterRendersCorrectlyInteractive)

	TEST_P (AiksTest, ClippedBlurFilterRendersCorrectly)

	TEST_P (AiksTest, ClearBlendWithBlur)

	TEST_P (AiksTest, BlurHasNoEdge)

	TEST_P (AiksTest, MaskBlurWithZeroSigmaIsSkipped)

	TEST_P (AiksTest, MaskBlurOnZeroDimensionIsSkippedWideGamut)

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

	TEST_P (AiksTest, GaussianBlurStyleInner)

	TEST_P (AiksTest, GaussianBlurStyleOuter)

	TEST_P (AiksTest, GaussianBlurStyleSolid)

	TEST_P (AiksTest, MaskBlurTexture)

	TEST_P (AiksTest, MaskBlurDoesntStretchContents)

	TEST_P (AiksTest, GaussianBlurAtPeripheryVertical)

	TEST_P (AiksTest, GaussianBlurAtPeripheryHorizontal)

	TEST_P (AiksTest, GaussianBlurAnimatedBackdrop)

	TEST_P (AiksTest, GaussianBlurStyleInnerGradient)

	TEST_P (AiksTest, GaussianBlurStyleSolidGradient)

	TEST_P (AiksTest, GaussianBlurStyleOuterGradient)

	TEST_P (AiksTest, GaussianBlurScaledAndClipped)

	TEST_P (AiksTest, GaussianBlurRotatedAndClippedInteractive)

	TEST_P (AiksTest, GaussianBlurOneDimension)

	TEST_P (AiksTest, GaussianBlurRotatedAndClipped)

	TEST_P (AiksTest, GaussianBlurRotatedNonUniform)

	TEST_P (AiksTest, BlurredRectangleWithShader)

	TEST_P (AiksTest, GaussianBlurSolidColorTinyMipMap)

	TEST_P (AiksTest, GaussianBlurBackdropTinyMipMap)

	TEST_P (AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropIdDifferentLayers)

	TEST_P (AiksTest, BlurGradientWithOpacity)

	TEST_P (AiksTest, CanRenderNestedClips)

	TEST_P (AiksTest, CanRenderDifferenceClips)

	TEST_P (AiksTest, CanRenderWithContiguousClipRestores)

	TEST_P (AiksTest, ClipsUseCurrentTransform)

	TEST_P (AiksTest, FramebufferBlendsRespectClips)

	TEST_P (AiksTest, CanRenderLinearGradientClamp)

	TEST_P (AiksTest, CanRenderLinearGradientRepeat)

	TEST_P (AiksTest, CanRenderLinearGradientMirror)

	TEST_P (AiksTest, CanRenderLinearGradientDecal)

	TEST_P (AiksTest, CanRenderLinearGradientDecalWithColorFilter)

static void	CanRenderLinearGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderLinearGradientWithDitheringEnabled)

static void	CanRenderRadialGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderRadialGradientWithDitheringEnabled)

static void	CanRenderSweepGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderSweepGradientWithDitheringEnabled)

static void	CanRenderConicalGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderConicalGradientWithDitheringEnabled)

	TEST_P (AiksTest, CanRenderLinearGradientWithOverlappingStopsClamp)

	TEST_P (AiksTest, CanRenderLinearGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderRadialGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderConicalGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderSweepGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsClamp)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsRepeat)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsMirror)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsDecal)

	TEST_P (AiksTest, CanRenderLinearGradientWayManyColorsClamp)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsUnevenStops)

	TEST_P (AiksTest, CanRenderLinearGradientMaskBlur)

	TEST_P (AiksTest, CanRenderRadialGradient)

	TEST_P (AiksTest, CanRenderRadialGradientManyColors)

	TEST_P (AiksTest, CanRenderSweepGradientClamp)

	TEST_P (AiksTest, CanRenderSweepGradientRepeat)

	TEST_P (AiksTest, CanRenderSweepGradientMirror)

	TEST_P (AiksTest, CanRenderSweepGradientDecal)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsClamp)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsRepeat)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsMirror)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsDecal)

	TEST_P (AiksTest, CanRenderConicalGradient)

	TEST_P (AiksTest, CanRenderGradientDecalWithBackground)

	TEST_P (AiksTest, GradientStrokesRenderCorrectly)

	TEST_P (AiksTest, FastGradientTestHorizontal)

	TEST_P (AiksTest, FastGradientTestVertical)

	TEST_P (AiksTest, FastGradientTestHorizontalReversed)

	TEST_P (AiksTest, FastGradientTestVerticalReversed)

	TEST_P (AiksTest, VerifyNonOptimizedGradient)

	TEST_P (AiksTest, DrawOpacityPeephole)

	TEST_P (AiksTest, CanRenderGroupOpacity)

	TEST_P (AiksTest, CanRenderGroupOpacityToSavelayer)

	TEST_P (AiksTest, RotateColorFilteredPath)

	TEST_P (AiksTest, CanRenderStrokes)

	TEST_P (AiksTest, CanRenderCurvedStrokes)

	TEST_P (AiksTest, CanRenderThickCurvedStrokes)

	TEST_P (AiksTest, CanRenderThinCurvedStrokes)

	TEST_P (AiksTest, CanRenderStrokePathThatEndsAtSharpTurn)

	TEST_P (AiksTest, CanRenderStrokePathWithCubicLine)

	TEST_P (AiksTest, CanRenderQuadraticStrokeWithInstantTurn)

	TEST_P (AiksTest, CanRenderFilledConicPaths)

	TEST_P (AiksTest, CanRenderStrokedConicPaths)

	TEST_P (AiksTest, HairlinePath)

	TEST_P (AiksTest, HairlineDrawLine)

	TEST_P (AiksTest, CanRenderTightConicPath)

	TEST_P (AiksTest, CanRenderDifferencePaths)

	TEST_P (AiksTest, CanDrawAnOpenPath)

	TEST_P (AiksTest, CanDrawAnOpenPathThatIsntARect)

	TEST_P (AiksTest, SolidStrokesRenderCorrectly)

	TEST_P (AiksTest, DrawLinesRenderCorrectly)

	TEST_P (AiksTest, ScaleExperimentAntialiasLines)

	TEST_P (AiksTest, HexagonExperimentAntialiasLines)

	TEST_P (AiksTest, SimpleExperimentAntialiasLines)

	TEST_P (AiksTest, DrawRectStrokesRenderCorrectly)

	TEST_P (AiksTest, DrawRectStrokesWithBevelJoinRenderCorrectly)

	TEST_P (AiksTest, CanDrawMultiContourConvexPath)

	TEST_P (AiksTest, ArcWithZeroSweepAndBlur)

	TEST_P (AiksTest, CanRenderClips)

	TEST_P (AiksTest, FatStrokeArc)

	TEST_P (AiksTest, CanRenderOverlappingMultiContourPath)

	TEST_P (AiksTest, TwoContourPathWithSinglePointContour)

	TEST_P (AiksTest, StrokeCapsAndJoins)

	TEST_P (AiksTest, BlurredCircleWithStrokeWidth)

	TEST_P (AiksTest, CanRenderClippedRuntimeEffects)

	TEST_P (AiksTest, DrawPaintTransformsBounds)

	TEST_P (AiksTest, CanRenderRuntimeEffectFilter)

	TEST_P (AiksTest, RuntimeEffectWithInvalidSamplerDoesNotCrash)

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

	TEST_P (AiksTest, CanRenderTextFrame)

	TEST_P (AiksTest, CanRenderTextFrameWithInvertedTransform)

	TEST_P (AiksTest, CanRenderStrokedTextFrame)

	TEST_P (AiksTest, CanRenderTextStrokeWidth)

	TEST_P (AiksTest, CanRenderTextFrameWithHalfScaling)

	TEST_P (AiksTest, ScaledK)

	TEST_P (AiksTest, MassiveScaleConvertToPath)

	TEST_P (AiksTest, CanRenderTextFrameWithScalingOverflow)

	TEST_P (AiksTest, CanRenderTextFrameWithFractionScaling)

	TEST_P (AiksTest, TextRotated180Degrees)

	TEST_P (AiksTest, TextFrameSubpixelAlignment)

	TEST_P (AiksTest, CanRenderItalicizedText)

	TEST_P (AiksTest, CanRenderEmojiTextFrame)

	TEST_P (AiksTest, CanRenderEmojiTextFrameWithBlur)

	TEST_P (AiksTest, CanRenderEmojiTextFrameWithAlpha)

	TEST_P (AiksTest, CanRenderTextInSaveLayer)

	TEST_P (AiksTest, CanRenderTextOutsideBoundaries)

	TEST_P (AiksTest, TextRotated)

	TEST_P (AiksTest, DrawScaledTextWithPerspectiveNoSaveLayer)

	TEST_P (AiksTest, DrawScaledTextWithPerspectiveSaveLayer)

	TEST_P (AiksTest, CanRenderTextWithLargePerspectiveTransform)

	TEST_P (AiksTest, CanRenderTextWithPerspectiveTransformInSublist)

	TEST_P (AiksTest, TextForegroundShaderWithTransform)

	TEST_P (AiksTest, DifferenceClipsMustRenderIdenticallyAcrossBackends)

	TEST_P (AiksTest, TextContentsMismatchedTransformTest)

	TEST_P (AiksTest, TextWithShadowCache)

	TEST_P (AiksTest, MultipleTextWithShadowCache)

	TEST_P (AiksTest, SingleIconShadowTest)

	TEST_P (AiksTest, VarietyOfTextScalesShowingRasterAndPath)

	TEST_P (AiksTest, CollapsedDrawPaintInSubpass)

	TEST_P (AiksTest, CollapsedDrawPaintInSubpassBackdropFilter)

	TEST_P (AiksTest, ColorMatrixFilterSubpassCollapseOptimization)

	TEST_P (AiksTest, LinearToSrgbFilterSubpassCollapseOptimization)

	TEST_P (AiksTest, SrgbToLinearFilterSubpassCollapseOptimization)

	TEST_P (AiksTest, TranslucentSaveLayerDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly)

	TEST_P (AiksTest, ImageFilteredUnboundedSaveLayerWithUnboundedContents)

	TEST_P (AiksTest, TranslucentSaveLayerImageDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorFilterAndImageFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly)

	TEST_P (AiksTest, CanRenderTinyOverlappingSubpasses)

	TEST_P (AiksTest, CanRenderDestructiveSaveLayer)

	TEST_P (AiksTest, CanDrawPoints)

	TEST_P (AiksTest, CanDrawPointsWithTextureMap)

	TEST_P (AiksTest, MipmapGenerationWorksCorrectly)

	TEST_P (AiksTest, StrokedPathWithMoveToThenCloseDrawnCorrectly)

	TEST_P (AiksTest, SetContentsWithRegion)

	TEST_P (AiksTest, ReleasesTextureOnTeardown)

	TEST_P (AiksTest, MatrixImageFilterMagnify)

	TEST_P (AiksTest, ImageFilteredSaveLayerWithUnboundedContents)

	TEST_P (AiksTest, MatrixBackdropFilter)

	TEST_P (AiksTest, MatrixSaveLayerFilter)

	TEST_P (AiksTest, CanDrawScaledPointsSmallScaleLargeRadius)

	TEST_P (AiksTest, CanDrawScaledPointsLargeScaleSmallRadius)

	TEST_P (AiksTest, TransparentShadowProducesCorrectColor)

	TEST_P (AiksTest, DispatcherDoesNotCullPerspectiveTransformedChildDisplayLists)

	TEST_P (AiksTest, BackdropRestoreUsesCorrectCoverageForFirstRestoredClip)

	TEST_P (AiksTest, CanPictureConvertToImage)

	TEST_P (AiksTest, CanEmptyPictureConvertToImage)

	TEST_P (AiksTest, DepthValuesForLineMode)

	TEST_P (AiksTest, DepthValuesForPolygonMode)

	TEST_P (AiksTest, ToImageFromImage)

	TEST_P (AiksTest, DisplayListToTextureAllocationFailure)

	TEST_P (AiksTest, DisplayListToTextureWithMipGeneration)

	TEST_P (AiksTest, VerticesGeometryUVPositionData)

	TEST_P (AiksTest, VerticesGeometryUVPositionDataWithTranslate)

	TEST_P (AiksTest, VerticesGeometryColorUVPositionData)

	TEST_P (AiksTest, VerticesGeometryColorUVPositionDataAdvancedBlend)

	TEST_P (AiksTest, CanConvertTriangleFanToTriangles)

	TEST_P (AiksTest, DrawVerticesSolidColorTrianglesWithoutIndices)

	TEST_P (AiksTest, DrawVerticesLinearGradientWithoutIndices)

	TEST_P (AiksTest, DrawVerticesLinearGradientWithTextureCoordinates)

	TEST_P (AiksTest, DrawVerticesImageSourceWithTextureCoordinates)

	TEST_P (AiksTest, DrawVerticesImageSourceWithTextureCoordinatesAndColorBlending)

	TEST_P (AiksTest, DrawVerticesSolidColorTrianglesWithIndices)

	TEST_P (AiksTest, DrawVerticesPremultipliesColors)

	TEST_P (AiksTest, DrawVerticesWithInvalidIndices)

	TEST_P (AiksTest, DrawVerticesTextureCoordinatesWithFragmentShader)

	TEST_P (AiksTest, DrawVerticesTextureCoordinatesWithFragmentShaderNonZeroOrigin)

	TEST_P (AiksTest, VerticesGeometryWithMaskFilter)

	INSTANTIATE_PLAYGROUND_SUITE (AiksTest)

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

	TEST_P (AiksTest, TransformMultipliesCorrectly)

	TEST_P (AiksTest, CanvasCanPushPopCTM)

	TEST_P (AiksTest, CanvasCTMCanBeUpdated)

	TEST_P (AiksTest, BackdropCountDownNormal)

	TEST_P (AiksTest, BackdropCountDownBackdropId)

	TEST_P (AiksTest, BackdropCountDownBackdropIdMixed)

	TEST_P (AiksTest, BackdropCountDownWithNestedSaveLayers)

	TEST_P (AiksTest, DrawVerticesLinearGradientWithEmptySize)

	TEST_P (AiksTest, DrawVerticesWithEmptyTextureCoordinates)

	TEST_P (AiksTest, SupportsBlitToOnscreen)

	TEST_P (AiksTest, RoundSuperellipseShadowComparison)

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

	TEST_P (DisplayListTest, DrawPaintIgnoresMaskFilter)

	TEST_P (DisplayListTest, DrawMaskBlursThatMightUseSaveLayers)

	TEST (PaintTest, GradientStopConversion)

	TEST (PaintTest, GradientMissing0)

	TEST (PaintTest, GradientMissingLastValue)

	TEST (PaintTest, GradientStopGreaterThan1)

	TEST (PaintTest, GradientConversionNonMonotonic)

	TEST (SkiaConversionTest, ToSamplerDescriptor)

	TEST (SkiaConversionsTest, ToColor)

	TEST (EntityPassClipStackTest, CanPushAndPopEntities)

	TEST (EntityPassClipStackTest, CanPopEntitiesSafely)

	TEST (EntityPassClipStackTest, AppendAndRestoreClipCoverage)

	TEST (EntityPassClipStackTest, AppendAndRestoreClipCoverageNonAA)

	TEST (EntityPassClipStackTest, AppendLargerClipCoverage)

	TEST (EntityPassClipStackTest, AppendLargerClipCoverageWithDifferenceOrNonSquare)

	TEST (EntityPassClipStackTest, AppendDecreasingSizeClipCoverage)

	TEST (EntityPassClipStackTest, AppendIncreasingSizeClipCoverage)

	TEST (EntityPassClipStackTest, UnbalancedRestore)

	TEST (EntityPassClipStackTest, ClipAndRestoreWithSubpasses)

	TEST (EntityPassClipStackTest, ClipAndRestoreWithSubpassesNonAA)

	INSTANTIATE_PLAYGROUND_SUITE (BlendFilterContentsTest)

	TEST_P (BlendFilterContentsTest, AdvancedBlendColorAlignsColorTo4)

	INSTANTIATE_PLAYGROUND_SUITE (GaussianBlurFilterContentsTest)

	TEST (GaussianBlurFilterContentsTest, Create)

	TEST (GaussianBlurFilterContentsTest, CoverageEmpty)

	TEST (GaussianBlurFilterContentsTest, CoverageSimple)

	TEST (GaussianBlurFilterContentsTest, CoverageWithSigma)

	TEST_P (GaussianBlurFilterContentsTest, CoverageWithTexture)

	TEST_P (GaussianBlurFilterContentsTest, CoverageWithEffectTransform)

	TEST (GaussianBlurFilterContentsTest, FilterSourceCoverage)

	TEST (GaussianBlurFilterContentsTest, CalculateSigmaValues)

	TEST_P (GaussianBlurFilterContentsTest, RenderCoverageMatchesGetCoverage)

	TEST_P (GaussianBlurFilterContentsTest, RenderCoverageMatchesGetCoverageTranslate)

	TEST_P (GaussianBlurFilterContentsTest, RenderCoverageMatchesGetCoverageRotated)

	TEST_P (GaussianBlurFilterContentsTest, CalculateUVsSimple)

	TEST_P (GaussianBlurFilterContentsTest, TextureContentsWithDestinationRect)

	TEST_P (GaussianBlurFilterContentsTest, TextureContentsWithDestinationRectScaled)

	TEST_P (GaussianBlurFilterContentsTest, TextureContentsWithEffectTransform)

	TEST (GaussianBlurFilterContentsTest, CalculateSigmaForBlurRadius)

	TEST (GaussianBlurFilterContentsTest, Coefficients)

	TEST (GaussianBlurFilterContentsTest, LerpHackKernelSamplesSimple)

	TEST (GaussianBlurFilterContentsTest, LerpHackKernelSamplesComplex)

	TEST (GaussianBlurFilterContentsTest, ChopHugeBlurs)

	TEST (FilterInputTest, CanSetLocalTransformForTexture)

	INSTANTIATE_PLAYGROUND_SUITE (MatrixFilterContentsTest)

	TEST (MatrixFilterContentsTest, CoverageEmpty)

	TEST (MatrixFilterContentsTest, CoverageSimple)

	TEST (MatrixFilterContentsTest, Coverage2x)

	TEST (MatrixFilterContentsTest, Coverage2xEffect)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageIdentity)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageTranslate)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageClippedSubpassTranslate)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageScale)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageClippedSubpassScale)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageSubpassScale)

	INSTANTIATE_PLAYGROUND_SUITE (HostBufferTest)

	TEST_P (HostBufferTest, IdleWaiter)

	TEST_P (HostBufferTest, CanEmplace)

	TEST_P (HostBufferTest, CanEmplaceWithAlignment)

	TEST_P (HostBufferTest, HostBufferInitialState)

	TEST_P (HostBufferTest, ResetIncrementsFrameCounter)

	TEST_P (HostBufferTest, EmplacingLargerThanBlockSizeCreatesOneOffBufferCallback)

	TEST_P (HostBufferTest, EmplacingLargerThanBlockSizeCreatesOneOffBuffer)

	TEST_P (HostBufferTest, UnusedBuffersAreDiscardedWhenResetting)

	TEST_P (HostBufferTest, EmplaceWithProcIsAligned)

	TEST_P (HostBufferTest, EmplaceWithFailingAllocationDoesntCrash)

	TEST (LineContents, Create)

	TEST (LineContents, CalculatePerVertex)

	TEST (LineContents, CreateCurveData)

	TEST (LineContents, CreateCurveDataScaled)

	TEST (LineContents, CalculatePerVertexLimit)

	INSTANTIATE_PLAYGROUND_SUITE (TextContentsTest)

	TEST_P (TextContentsTest, SimpleComputeVertexData)

	TEST_P (TextContentsTest, SimpleComputeVertexData2x)

	TEST_P (TextContentsTest, MaintainsShape)

	TEST_P (TextContentsTest, SimpleSubpixel)

	TEST_P (TextContentsTest, SimpleSubpixel3x)

	TEST_P (TextContentsTest, SimpleSubpixel26)

	TEST_P (TextContentsTest, SimpleSubpixel80)

	TEST_P (EntityTest, TiledTextureContentsRendersWithCorrectPipeline)

	TEST_P (EntityTest, TiledTextureContentsRendersWithCorrectPipelineExternalOES)

	TEST (DrawOrderResolverTest, GetSortedDrawsReturnsCorrectOrderWithNoClips)

	TEST (DrawOrderResolverTest, GetSortedDrawsReturnsCorrectOrderWithClips)

	TEST (DrawOrderResolverTest, GetSortedDrawsRespectsSkipCounts)

	TEST (DrawOrderResolverTest, GetSortedDrawsReturnsCorrectOrderWithFlush)

	TEST_P (EntityPassTargetTest, SwapWithMSAATexture)

	TEST_P (EntityPassTargetTest, SwapWithMSAAImplicitResolve)

Rect	RectMakeCenterSize (Point center, Size size)

	TEST_P (EntityTest, CanCreateEntity)

	TEST_P (EntityTest, FilterCoverageRespectsCropRect)

	TEST_P (EntityTest, GeometryBoundsAreTransformed)

	TEST_P (EntityTest, ThreeStrokesInOnePath)

	TEST_P (EntityTest, StrokeWithTextureContents)

	TEST_P (EntityTest, TriangleInsideASquare)

	TEST_P (EntityTest, StrokeCapAndJoinTest)

	TEST_P (EntityTest, CubicCurveTest)

	TEST_P (EntityTest, CanDrawCorrectlyWithRotatedTransform)

	TEST_P (EntityTest, CubicCurveAndOverlapTest)

	TEST_P (EntityTest, SolidColorContentsStrokeSetStrokeCapsAndJoins)

	TEST_P (EntityTest, SolidColorContentsStrokeSetMiterLimit)

	TEST_P (EntityTest, BlendingModeOptions)

	TEST_P (EntityTest, BezierCircleScaled)

	TEST_P (EntityTest, Filters)

	TEST_P (EntityTest, GaussianBlurFilter)

	TEST_P (EntityTest, MorphologyFilter)

	TEST_P (EntityTest, SetBlendMode)

	TEST_P (EntityTest, ContentsGetBoundsForEmptyPathReturnsNullopt)

	TEST_P (EntityTest, SolidStrokeCoverageIsCorrect)

	TEST_P (EntityTest, BorderMaskBlurCoverageIsCorrect)

	TEST_P (EntityTest, SolidFillCoverageIsCorrect)

	TEST_P (EntityTest, RRectShadowTest)

	TEST_P (EntityTest, ColorMatrixFilterCoverageIsCorrect)

	TEST_P (EntityTest, ColorMatrixFilterEditable)

	TEST_P (EntityTest, LinearToSrgbFilterCoverageIsCorrect)

	TEST_P (EntityTest, LinearToSrgbFilter)

	TEST_P (EntityTest, SrgbToLinearFilterCoverageIsCorrect)

	TEST_P (EntityTest, SrgbToLinearFilter)

static Vector3	RGBToYUV (Vector3 rgb, YUVColorSpace yuv_color_space)

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

	TEST_P (EntityTest, YUVToRGBFilter)

	TEST_P (EntityTest, RuntimeEffect)

	TEST_P (EntityTest, RuntimeEffectCanSuccessfullyRender)

	TEST_P (EntityTest, RuntimeEffectCanPrecache)

	TEST_P (EntityTest, RuntimeEffectSetsRightSizeWhenUniformIsStruct)

	TEST_P (EntityTest, ColorFilterWithForegroundColorAdvancedBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorClearBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorSrcBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorDstBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorSrcInBlend)

	TEST_P (EntityTest, CoverageForStrokePathWithNegativeValuesInTransform)

	TEST_P (EntityTest, SolidColorContentsIsOpaque)

	TEST_P (EntityTest, ConicalGradientContentsIsOpaque)

	TEST_P (EntityTest, LinearGradientContentsIsOpaque)

	TEST_P (EntityTest, RadialGradientContentsIsOpaque)

	TEST_P (EntityTest, SweepGradientContentsIsOpaque)

	TEST_P (EntityTest, TiledTextureContentsIsOpaque)

	TEST_P (EntityTest, PointFieldGeometryCoverage)

	TEST_P (EntityTest, ColorFilterContentsWithLargeGeometry)

	TEST_P (EntityTest, TextContentsCeilsGlyphScaleToDecimal)

	TEST_P (EntityTest, SpecializationConstantsAreAppliedToVariants)

	TEST_P (EntityTest, DecalSpecializationAppliedToMorphologyFilter)

	TEST_P (EntityTest, ContentContextOptionsHasReasonableHashFunctions)

	TEST_P (EntityTest, FillPathGeometryGetPositionBufferReturnsExpectedMode)

	TEST_P (EntityTest, FailOnValidationError)

	TEST_P (EntityTest, CanComputeGeometryForEmptyPathsWithoutCrashing)

	TEST_P (EntityTest, CanRenderEmptyPathsWithoutCrashing)

	TEST_P (EntityTest, DrawSuperEllipse)

	TEST_P (EntityTest, DrawRoundSuperEllipse)

	TEST_P (EntityTest, SolidColorApplyColorFilter)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Linear)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Radial)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Conical)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Sweep)

	TEST_P (EntityTest, GiantStrokePathAllocation)

	TEST_P (EntityTest, RoundSuperellipseGetPositionBufferFlushes)

	TEST (EntityGeometryTest, RectGeometryCoversArea)

	TEST (EntityGeometryTest, FillPathGeometryCoversArea)

	TEST (EntityGeometryTest, FillPathGeometryCoversAreaNoInnerRect)

	TEST (EntityGeometryTest, FillArcGeometryCoverage)

	TEST (EntityGeometryTest, StrokeArcGeometryCoverage)

	TEST (EntityGeometryTest, FillRoundRectGeometryCoversArea)

	TEST (EntityGeometryTest, LineGeometryCoverage)

	TEST (EntityGeometryTest, RoundRectGeometryCoversArea)

	TEST (EntityGeometryTest, GeometryResultHasReasonableDefaults)

	TEST (EntityGeometryTest, AlphaCoverageStrokePaths)

	TEST (EntityGeometryTest, SimpleTwoLineStrokeVerticesButtCap)

	TEST (EntityGeometryTest, SimpleTwoLineStrokeVerticesRoundCap)

	TEST (EntityGeometryTest, SimpleTwoLineStrokeVerticesSquareCap)

	TEST (EntityGeometryTest, TwoLineSegmentsRightTurnStrokeVerticesBevelJoin)

	TEST (EntityGeometryTest, TwoLineSegmentsLeftTurnStrokeVerticesBevelJoin)

	TEST (EntityGeometryTest, TwoLineSegmentsRightTurnStrokeVerticesMiterJoin)

	TEST (EntityGeometryTest, TwoLineSegmentsLeftTurnStrokeVerticesMiterJoin)

	TEST (EntityGeometryTest, TinyQuadGeneratesCaps)

	TEST (EntityGeometryTest, TinyConicGeneratesCaps)

	TEST (EntityGeometryTest, TinyCubicGeneratesCaps)

	TEST (EntityGeometryTest, TwoLineSegmentsMiterLimit)

	TEST (EntityGeometryTest, TwoLineSegments180DegreeJoins)

	TEST (EntityGeometryTest, TightQuadratic180DegreeJoins)

	TEST (EntityGeometryTest, TightConic180DegreeJoins)

	TEST (EntityGeometryTest, TightCubic180DegreeJoins)

	TEST (EntityGeometryTest, RotatedFilledCircleGeometryCoverage)

	TEST (EntityGeometryTest, RotatedStrokedCircleGeometryCoverage)

	TEST_P (RenderTargetCacheTest, CachesUsedTexturesAcrossFrames)

	TEST_P (RenderTargetCacheTest, CachesUsedTexturesAcrossFramesWithKeepAlive)

	TEST_P (RenderTargetCacheTest, DoesNotPersistFailedAllocations)

	TEST_P (RenderTargetCacheTest, CachedTextureGetsNewAttachmentConfig)

	TEST_P (RenderTargetCacheTest, CreateWithEmptySize)

	TEST (SaveLayerUtilsTest, SimplePaintComputedCoverage)

	TEST (SaveLayerUtilsTest, BackdropFiterComputedCoverage)

	TEST (SaveLayerUtilsTest, ImageFiterComputedCoverage)

	TEST (SaveLayerUtilsTest, ImageFiterSmallScaleComputedCoverageLargerThanBoundsLimit)

	TEST (SaveLayerUtilsTest, ImageFiterLargeScaleComputedCoverageLargerThanBoundsLimit)

	TEST (SaveLayerUtilsTest, DisjointCoverage)

	TEST (SaveLayerUtilsTest, DisjointCoverageTransformedByImageFilter)

	TEST (SaveLayerUtilsTest, DisjointCoveragTransformedByCTM)

	TEST (SaveLayerUtilsTest, BasicEmptyCoverage)

	TEST (SaveLayerUtilsTest, ImageFilterEmptyCoverage)

	TEST (SaveLayerUtilsTest, BackdropFilterEmptyCoverage)

	TEST (SaveLayerUtilsTest, FloodInputCoverage)

	TEST (SaveLayerUtilsTest, FloodInputCoverageWithImageFilter)

	TEST (SaveLayerUtilsTest, FloodInputCoverageWithImageFilterWithNoCoverageProducesNoCoverage)

	TEST (SaveLayerUtilsTest, CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageSmallerWithImageFilter)

	TEST (SaveLayerUtilsTest, CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageLargerWithImageFilter)

	TEST (SaveLayerUtilsTest, CoverageLimitRespectedIfSubstantiallyDifferentFromContentCoverage)

	TEST (SaveLayerUtilsTest, RoundUpCoverageWhenCloseToCoverageLimit)

	TEST (SaveLayerUtilsTest, DontRoundUpCoverageWhenNotCloseToCoverageLimitWidth)

	TEST (SaveLayerUtilsTest, DontRoundUpCoverageWhenNotCloseToCoverageLimitHeight)

	TEST (SaveLayerUtilsTest, DontRoundUpCoverageWhenNotCloseToCoverageLimitWidthHeight)

	TEST (ArcTest, ArcIterationsFullCircle)

	TEST (ArcTest, ArcIterationsVariousStartAnglesNearQuadrantAxis)

	TEST (ArcTest, ArcIterationsVariousEndAnglesNearQuadrantAxis)

	TEST (ArcTest, ArcIterationsVariousTinyArcsNearQuadrantAxis)

	TEST (ArcTest, ArcIterationsOnlyFirstQuadrant)

	TEST (ArcTest, ArcIterationsOnlySecondQuadrant)

	TEST (ArcTest, ArcIterationsOnlyThirdQuadrant)

	TEST (ArcTest, ArcIterationsOnlyFourthQuadrant)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromFirst)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromSecond)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromThird)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromFourth)

	TEST (GeometryTest, ScalarNearlyEqual)

	TEST (GeometryTest, MakeColumn)

	TEST (GeometryTest, MakeRow)

	TEST (GeometryTest, RotationMatrix)

	TEST (GeometryTest, InvertMultMatrix)

	TEST (GeometryTest, MatrixBasis)

	TEST (GeometryTest, MutliplicationMatrix)

	TEST (GeometryTest, DeterminantTest)

	TEST (GeometryTest, InvertMatrix)

	TEST (GeometryTest, TestDecomposition)

	TEST (GeometryTest, TestDecomposition2)

	TEST (GeometryTest, TestRecomposition)

	TEST (GeometryTest, TestRecomposition2)

	TEST (GeometryTest, MatrixVectorMultiplication)

	TEST (GeometryTest, MatrixMakeRotationFromQuaternion)

	TEST (GeometryTest, MatrixTransformDirection)

	TEST (GeometryTest, MatrixGetMaxBasisLengthXY)

	TEST (GeometryTest, MatrixMakeOrthographic)

	TEST (GeometryTest, MatrixMakePerspective)

	TEST (GeometryTest, MatrixGetBasisVectors)

	TEST (GeometryTest, MatrixGetDirectionScale)

	TEST (GeometryTest, MatrixTranslationScaleOnly)

	TEST (GeometryTest, MatrixLookAt)

	TEST (GeometryTest, QuaternionLerp)

	TEST (GeometryTest, QuaternionVectorMultiply)

	TEST (GeometryTest, CanGenerateMipCounts)

	TEST (GeometryTest, CanConvertTTypesExplicitly)

	TEST (GeometryTest, CanPerformAlgebraicPointOps)

	TEST (GeometryTest, CanPerformAlgebraicPointOpsWithArithmeticTypes)

	TEST (GeometryTest, PointIntegerCoercesToFloat)

	TEST (GeometryTest, SizeCoercesToPoint)

	TEST (GeometryTest, CanUsePointAssignmentOperators)

	TEST (GeometryTest, PointDotProduct)

	TEST (GeometryTest, PointCrossProduct)

	TEST (GeometryTest, PointReflect)

	TEST (GeometryTest, PointAbs)

	TEST (GeometryTest, PointRotate)

	TEST (GeometryTest, PointAngleTo)

	TEST (GeometryTest, PointMin)

	TEST (GeometryTest, Vector4IsFinite)

	TEST (GeometryTest, Vector3Min)

	TEST (GeometryTest, Vector4Min)

	TEST (GeometryTest, PointMax)

	TEST (GeometryTest, Vector3Max)

	TEST (GeometryTest, Vector4Max)

	TEST (GeometryTest, PointFloor)

	TEST (GeometryTest, Vector3Floor)

	TEST (GeometryTest, Vector4Floor)

	TEST (GeometryTest, PointCeil)

	TEST (GeometryTest, Vector3Ceil)

	TEST (GeometryTest, Vector4Ceil)

	TEST (GeometryTest, PointRound)

	TEST (GeometryTest, Vector3Round)

	TEST (GeometryTest, Vector4Round)

	TEST (GeometryTest, PointLerp)

	TEST (GeometryTest, Vector3Lerp)

	TEST (GeometryTest, Vector4Lerp)

	TEST (GeometryTest, SeparatedVector2NormalizesWithConstructor)

	TEST (GeometryTest, SeparatedVector2GetVector)

	TEST (GeometryTest, SeparatedVector2GetAlignment)

	TEST (GeometryTest, SeparatedVector2AngleTo)

	TEST (GeometryTest, CanUseVector3AssignmentOperators)

	TEST (GeometryTest, CanPerformAlgebraicVector3Ops)

	TEST (GeometryTest, CanPerformAlgebraicVector3OpsWithArithmeticTypes)

	TEST (GeometryTest, ColorPremultiply)

	TEST (GeometryTest, ColorR8G8B8A8)

	TEST (GeometryTest, ColorLerp)

	TEST (GeometryTest, ColorClamp01)

	TEST (GeometryTest, ColorMakeRGBA8)

	TEST (GeometryTest, ColorApplyColorMatrix)

	TEST (GeometryTest, ColorLinearToSRGB)

	TEST (GeometryTest, ColorSRGBToLinear)

	TEST (GeometryTest, ColorBlendReturnsExpectedResults)

	TEST (GeometryTest, BlendModeToString)

	TEST (GeometryTest, CanConvertBetweenDegressAndRadians)

	TEST (GeometryTest, MatrixPrinting)

	TEST (GeometryTest, PointPrinting)

	TEST (GeometryTest, Vector3Printing)

	TEST (GeometryTest, Vector4Printing)

	TEST (GeometryTest, ColorPrinting)

	TEST (GeometryTest, ToIColor)

	TEST (GeometryTest, Gradient)

	TEST (GeometryTest, HalfConversions)

	TEST (MatrixTest, Multiply)

	TEST (MatrixTest, Equals)

	TEST (MatrixTest, NotEquals)

	TEST (MatrixTest, HasPerspective2D)

	TEST (MatrixTest, HasPerspective)

	TEST (MatrixTest, HasTranslation)

	TEST (MatrixTest, IsTranslationOnly)

	TEST (MatrixTest, IsTranslationScaleOnly)

	TEST (MatrixTest, IsInvertibleGetDeterminant)

	TEST (MatrixTest, IsFinite)

	TEST (MatrixTest, IsAligned2D)

	TEST (MatrixTest, IsAligned)

	TEST (MatrixTest, TransformHomogenous)

	TEST (MatrixTest, GetMaxBasisXYNegativeScale)

	TEST (MatrixTest, GetMaxBasisXYWithLargeAndSmallScalingFactor)

	TEST (MatrixTest, GetMaxBasisXYWithLargeAndSmallScalingFactorNonScaleTranslate)

	TEST (MatrixTest, TranslateWithPerspective)

	TEST (MatrixTest, MakeScaleTranslate)

	TEST (MatrixTest, To3x3)

	TEST (PathSourceTest, RectSourceTest)

	TEST (PathSourceTest, EllipseSourceTest)

	TEST (PathSourceTest, RoundRectSourceTest)

	TEST (PathSourceTest, DiffRoundRectSourceTest)

	TEST (PathSourceTest, DashedLinePathSource)

	TEST (PathSourceTest, EmptyDashedLinePathSource)

	TEST (PathSourceTest, DashedLinePathSourceZeroOffGaps)

	TEST (PathSourceTest, DashedLinePathSourceInvalidOffGaps)

	TEST (PathSourceTest, DashedLinePathSourceInvalidOnRegion)

	TEST (RectTest, RectEmptyDeclaration)

	TEST (RectTest, IRectEmptyDeclaration)

	TEST (RectTest, RectDefaultConstructor)

	TEST (RectTest, IRectDefaultConstructor)

	TEST (RectTest, RectSimpleLTRB)

	TEST (RectTest, IRectSimpleLTRB)

	TEST (RectTest, RectSimpleXYWH)

	TEST (RectTest, IRectSimpleXYWH)

	TEST (RectTest, RectSimpleWH)

	TEST (RectTest, IRectSimpleWH)

	TEST (RectTest, RectFromIRect)

	TEST (RectTest, 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 (RoundRectTest, EmptyDeclaration)

	TEST (RoundRectTest, DefaultConstructor)

	TEST (RoundRectTest, EmptyRectConstruction)

	TEST (RoundRectTest, RectConstructor)

	TEST (RoundRectTest, InvertedRectConstruction)

	TEST (RoundRectTest, EmptyOvalConstruction)

	TEST (RoundRectTest, OvalConstructor)

	TEST (RoundRectTest, InvertedOvalConstruction)

	TEST (RoundRectTest, RectRadiusConstructor)

	TEST (RoundRectTest, RectXYConstructor)

	TEST (RoundRectTest, RectSizeConstructor)

	TEST (RoundRectTest, RectRadiiConstructor)

	TEST (RoundRectTest, RectRadiiOverflowWidthConstructor)

	TEST (RoundRectTest, RectRadiiOverflowHeightConstructor)

	TEST (RoundRectTest, Shift)

	TEST (RoundRectTest, ExpandScalar)

	TEST (RoundRectTest, ExpandTwoScalars)

	TEST (RoundRectTest, ExpandFourScalars)

	TEST (RoundRectTest, ContractScalar)

	TEST (RoundRectTest, ContractTwoScalars)

	TEST (RoundRectTest, ContractFourScalars)

	TEST (RoundRectTest, ContractAndRequireRadiiAdjustment)

	TEST (RoundRectTest, NoCornerRoundRectContains)

	TEST (RoundRectTest, TinyCornerRoundRectContains)

	TEST (RoundRectTest, UniformCircularRoundRectContains)

	TEST (RoundRectTest, UniformEllipticalRoundRectContains)

	TEST (RoundRectTest, DifferingCornersRoundRectContains)

	TEST (RoundSuperellipseTest, EmptyDeclaration)

	TEST (RoundSuperellipseTest, DefaultConstructor)

	TEST (RoundSuperellipseTest, EmptyRectConstruction)

	TEST (RoundSuperellipseTest, RectConstructor)

	TEST (RoundSuperellipseTest, InvertedRectConstruction)

	TEST (RoundSuperellipseTest, EmptyOvalConstruction)

	TEST (RoundSuperellipseTest, OvalConstructor)

	TEST (RoundSuperellipseTest, InvertedOvalConstruction)

	TEST (RoundSuperellipseTest, RectRadiusConstructor)

	TEST (RoundSuperellipseTest, RectXYConstructor)

	TEST (RoundSuperellipseTest, RectSizeConstructor)

	TEST (RoundSuperellipseTest, RectRadiiConstructor)

	TEST (RoundSuperellipseTest, RectRadiiOverflowWidthConstructor)

	TEST (RoundSuperellipseTest, RectRadiiOverflowHeightConstructor)

	TEST (RoundSuperellipseTest, Shift)

	TEST (RoundSuperellipseTest, ExpandScalar)

	TEST (RoundSuperellipseTest, ExpandTwoScalars)

	TEST (RoundSuperellipseTest, ExpandFourScalars)

	TEST (RoundSuperellipseTest, ContractScalar)

	TEST (RoundSuperellipseTest, ContractTwoScalars)

	TEST (RoundSuperellipseTest, ContractFourScalars)

	TEST (RoundSuperellipseTest, ContractAndRequireRadiiAdjustment)

	TEST (RoundSuperellipseTest, NoCornerRoundSuperellipseContains)

	TEST (RoundSuperellipseTest, TinyCornerContains)

	TEST (RoundSuperellipseTest, UniformSquareContains)

	TEST (RoundSuperellipseTest, UniformEllipticalContains)

	TEST (RoundSuperellipseTest, UniformRectangularContains)

	TEST (RoundSuperellipseTest, SlimDiagonalContains)

	TEST (RoundSuperellipseTest, PointsOutsideOfSharpCorner)

	TEST (RoundSuperellipseTest, PathForRectangularRseWithShapeCornersShouldBeWithinBounds)

	TEST (RoudingRadiiTest, RoundingRadiiEmptyDeclaration)

	TEST (RoudingRadiiTest, RoundingRadiiDefaultConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiScalarConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiEmptyScalarConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiSizeConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiEmptySizeConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiNamedSizesConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiPartialNamedSizesConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiMultiply)

	TEST (RoudingRadiiTest, RoundingRadiiEquals)

	TEST (RoudingRadiiTest, RoundingRadiiNotEquals)

	TEST (RoudingRadiiTest, RoundingRadiiCornersSameTolerance)

	TEST (RSTransformTest, Construction)

	TEST (RSTransformTest, CompareToMatrix)

	TEST (SaturatedMath, ExplicitAddOfSignedInts)

	TEST (SaturatedMath, ImplicitAddOfSignedInts)

	TEST (SaturatedMath, ExplicitAddOfFloatingPoint)

	TEST (SaturatedMath, ImplicitAddOfFloatingPoint)

	TEST (SaturatedMath, ExplicitSubOfSignedInts)

	TEST (SaturatedMath, ImplicitSubOfSignedInts)

	TEST (SaturatedMath, ExplicitSubOfFloatingPoint)

	TEST (SaturatedMath, ImplicitSubOfFloatingPoint)

	TEST (SaturatedMath, ExplicitAverageScalarOfSignedInts)

	TEST (SaturatedMath, ImplicitAverageScalarOfSignedInts)

	TEST (SaturatedMath, ExplicitAverageScalarOfFloatingPoint)

	TEST (SaturatedMath, ImplicitAverageScalarOfFloatingPoint)

	TEST (SaturatedMath, CastingFiniteDoubleToFloatStaysFinite)

	TEST (SaturatedMath, CastingInfiniteDoubleToFloatStaysInfinite)

	TEST (SaturatedMath, CastingNaNDoubleToFloatStaysNaN)

	TEST (SaturatedMath, CastingLargeScalarToSignedIntProducesLimit)

	TEST (SaturatedMath, CastingInfiniteScalarToSignedIntProducesLimit)

	TEST (SaturatedMath, CastingNaNScalarToSignedIntProducesZero)

	TEST (SizeTest, SizeIsEmpty)

	TEST (SizeTest, ISizeIsEmpty)

	TEST (SizeTest, IsSquare)

	TEST (SizeTest, MaxDimension)

	TEST (SizeTest, NegationOperator)

	TEST (TrigTest, TrigAngles)

	TEST (TrigTest, MultiplyByScalarRadius)

	TEST_F (GoldenTests, ConicalGradient)

	FML_TEST_CLASS (BufferBindingsGLESTest, BindUniformData)

	FML_TEST_CLASS (BufferBindingsGLESTest, BindArrayData)

	TEST (BufferBindingsGLESTest, BindUniformData)

	TEST (BufferBindingsGLESTest, BindArrayData)

	TEST (DeviceBufferGLESTest, BindUniformData)

	TEST (UniqueHandleGLES, MakeUntracked)

	INSTANTIATE_METAL_PLAYGROUND_SUITE (AllocatorMTLTest)

	TEST_P (AllocatorMTLTest, DebugTraceMemoryStatistics)

	TEST_P (AllocatorMTLTest, ManagedMemory)

	TEST_P (ContextMTLTest, FlushTask)

	TEST_P (ContextMTLTest, FlushTaskWithGPULoss)

	TEST_P (SwapchainTransientsMTLTest, CanAllocateSwapchainTextures)

	TEST (AllocatorVKTest, ToVKImageUsageFlags)

	TEST (AllocatorVKTest, MemoryTypeSelectionSingleHeap)

	TEST (AllocatorVKTest, MemoryTypeSelectionTwoHeap)

	TEST (AllocatorVKTest, ImageResourceKeepsVulkanDeviceAlive)

	TEST (CommandEncoderVKTest, DeleteEncoderAfterThreadDies)

	TEST (CommandEncoderVKTest, CleanupAfterSubmit)

	TEST (CommandPoolRecyclerVKTest, GetsACommandPoolPerThread)

	TEST (CommandPoolRecyclerVKTest, GetsTheSameCommandPoolOnSameThread)

	TEST (CommandPoolRecyclerVKTest, ReclaimMakesCommandPoolAvailable)

	TEST (CommandPoolRecyclerVKTest, CommandBuffersAreRecycled)

	TEST (CommandPoolRecyclerVKTest, ExtraCommandBufferAllocationsTriggerTrim)

	TEST (CommandPoolRecyclerVKTest, RecyclerGlobalPoolMapSize)

	TEST (ContextVKTest, CommonHardwareConcurrencyConfigurations)

	TEST (ContextVKTest, DeletesCommandPools)

	TEST (ContextVKTest, DeletesCommandPoolsOnAllThreads)

	TEST (ContextVKTest, ThreadLocalCleanupDeletesCommandPool)

	TEST (ContextVKTest, DeletePipelineAfterContext)

	TEST (ContextVKTest, DeleteShaderFunctionAfterContext)

	TEST (ContextVKTest, DeletePipelineLibraryAfterContext)

	TEST (ContextVKTest, CanCreateContextInAbsenceOfValidationLayers)

	TEST (ContextVKTest, CanCreateContextWithValidationLayers)

	TEST (CapabilitiesVKTest, ContextInitializesWithNoStencilFormat)

	TEST (CapabilitiesVKTest, ContextFailsInitializationForNoCombinedDepthStencilFormat)

	TEST (ContextVKTest, WarmUpFunctionCreatesRenderPass)

	TEST (ContextVKTest, FatalMissingValidations)

	TEST (ContextVKTest, HasDefaultColorFormat)

	TEST (ContextVKTest, EmbedderOverridesUsesInstanceExtensions)

	TEST (ContextVKTest, EmbedderOverrides)

	TEST (ContextVKTest, BatchSubmitCommandBuffersOnArm)

	TEST (ContextVKTest, BatchSubmitCommandBuffersOnNonArm)

	TEST (ContextVKTest, AHBSwapchainCapabilitiesCanBeMissing)

	TEST (ContextVKTest, HashIsUniqueAcrossThreads)

	TEST (DescriptorPoolRecyclerVKTest, GetDescriptorPoolRecyclerCreatesNewPools)

	TEST (DescriptorPoolRecyclerVKTest, ReclaimMakesDescriptorPoolAvailable)

	TEST (DescriptorPoolRecyclerVKTest, ReclaimDropsDescriptorPoolIfSizeIsExceeded)

	TEST (DescriptorPoolRecyclerVKTest, MultipleCommandBuffersShareDescriptorPool)

	TEST (DescriptorPoolRecyclerVKTest, DescriptorsAreRecycled)

	INSTANTIATE_VULKAN_PLAYGROUND_SUITE (DriverInfoVKTest)

	TEST_P (DriverInfoVKTest, CanQueryDriverInfo)

	TEST_P (DriverInfoVKTest, CanDumpToLog)

	TEST (DriverInfoVKTest, CanIdentifyBadMaleoonDriver)

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

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

	TEST (DriverInfoVKTest, CanBatchSubmitCommandBuffers)

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

	TEST (DriverInfoVKTest, CanUsePrimitiveRestart)

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

	TEST (DriverInfoVKTest, CanGenerateMipMaps)

	TEST (DriverInfoVKTest, DriverParsingMali)

	TEST (DriverInfoVKTest, DriverParsingAdreno)

	TEST (DriverInfoVKTest, DisabledDevices)

	TEST (DriverInfoVKTest, EnabledDevicesMali)

	TEST (DriverInfoVKTest, EnabledDevicesAdreno)

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

	TEST (DriverInfoVKTest, CanUseFramebufferFetch)

	TEST (DriverInfoVKTest, DisableOldXclipseDriver)

	TEST (DriverInfoVKTest, OldPowerVRDisabled)

	TEST (DriverInfoVKTest, NewPowerVREnabled)

	TEST (FenceWaiterVKTest, IgnoresNullFence)

	TEST (FenceWaiterVKTest, IgnoresNullCallback)

	TEST (FenceWaiterVKTest, ExecutesFenceCallback)

	TEST (FenceWaiterVKTest, ExecutesFenceCallbackX2)

	TEST (FenceWaiterVKTest, ExecutesNewFenceThenOldFence)

	TEST (FenceWaiterVKTest, AddFenceDoesNothingIfTerminating)

	TEST (FenceWaiterVKTest, InProgressFencesStillWaitIfTerminated)

	TEST (FormatsVKTest, DescriptorMapping)

	TEST (PipelineCacheDataVKTest, CanTestHeaderCompatibility)

	TEST (PipelineCacheDataVKTest, CanCreateFromDeviceProperties)

	TEST (PipelineCacheDataVKTest, WritesIncompleteCacheData)

	TEST_P (PipelineCacheDataVKPlaygroundTest, CanPersistAndRetrievePipelineCache)

	TEST_P (PipelineCacheDataVKPlaygroundTest, IntegrityChecksArePerformedOnPersistedData)

	TEST (RenderPassBuilder, CreatesRenderPassWithNoDepthStencil)

	TEST (RenderPassBuilder, RenderPassWithLoadOpUsesCurrentLayout)

	TEST (RenderPassBuilder, CreatesRenderPassWithCombinedDepthStencil)

	TEST (RenderPassBuilder, CreatesRenderPassWithOnlyStencil)

	TEST (RenderPassBuilder, CreatesMSAAResolveWithCorrectStore)

	TEST_P (RendererTest, CachesRenderPassAndFramebuffer)

	TEST_P (RendererTest, CachesRenderPassAndFramebufferNonMSAA)

	TEST_P (RendererTest, CachesRenderPassAndFramebufferMixed)

	TEST (RenderPassVK, DoesNotRedundantlySetStencil)

	TEST (ResourceManagerVKTest, CreatesANewInstance)

	TEST (ResourceManagerVKTest, ReclaimMovesAResourceAndDestroysIt)

	TEST (ResourceManagerVKTest, TerminatesWhenOutOfScope)

	TEST (ResourceManagerVKTest, IsThreadSafe)

	TEST (SurfaceContextVK, TearsDownSwapchain)

	TEST_P (BlitPassTest, BlitAcrossDifferentPixelFormatsFails)

	TEST_P (BlitPassTest, BlitAcrossDifferentSampleCountsFails)

	TEST_P (BlitPassTest, BlitPassesForMatchingFormats)

	TEST_P (BlitPassTest, ChecksInvalidSliceParameters)

	TEST_P (BlitPassTest, CanBlitSmallRegionToUninitializedTexture)

	TEST_P (BlitPassTest, ChecksInvalidMipLevelParameter)

	TEST_P (BlitPassTest, CanBlitToHigherTextureMipLevels)

	TEST_P (BlitPassTest, CanResizeTextures)

	TEST_P (BlitPassTest, CanResizeTexturesPlayground)

	CAPABILITY_TEST (SupportsOffscreenMSAA, false)

	CAPABILITY_TEST (SupportsSSBO, false)

	CAPABILITY_TEST (SupportsTextureToTextureBlits, false)

	CAPABILITY_TEST (SupportsFramebufferFetch, false)

	CAPABILITY_TEST (SupportsCompute, false)

	CAPABILITY_TEST (SupportsComputeSubgroups, false)

	CAPABILITY_TEST (SupportsReadFromResolve, false)

	CAPABILITY_TEST (SupportsDecalSamplerAddressMode, false)

	CAPABILITY_TEST (SupportsDeviceTransientTextures, false)

	CAPABILITY_TEST (SupportsTriangleFan, false)

	CAPABILITY_TEST (SupportsExtendedRangeFormats, false)

	TEST (CapabilitiesTest, DefaultColorFormat)

	TEST (CapabilitiesTest, DefaultStencilFormat)

	TEST (CapabilitiesTest, DefaultDepthStencilFormat)

	TEST (CapabilitiesTest, DefaultGlyphAtlasFormat)

	TEST (CapabilitiesTest, MaxRenderPassAttachmentSize)

	TEST (CapabilitiesTest, MinUniformAlignment)

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

	TEST_P (RendererTest, BindingNullTexturesDoesNotCrash)

	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 (PathTessellatorTest, EmptyPath)

	TEST (PathTessellatorTest, EmptyPathMultipleMoveTo)

	TEST (PathTessellatorTest, SimpleClosedPath)

	TEST (PathTessellatorTest, SimpleUnclosedPath)

	TEST (PathTessellatorTest, SimplePathTrailingMoveTo)

	TEST (PathTessellatorTest, DegenerateSegmentsPath)

	TEST (PathTessellatorTest, QuadToLineToOptimization)

	TEST (PathTessellatorTest, ConicToLineToOptimization)

	TEST (PathTessellatorTest, ConicToQuadToOptimization)

	TEST (PathTessellatorTest, SimplePathMultipleMoveTo)

	TEST (PathTessellatorTest, ComplexPath)

	TEST (PathTessellatorTest, ComplexPathTrailingMoveTo)

	TEST (PathTessellatorTest, LinearQuadToPointCount)

	TEST (PathTessellatorTest, LinearConicToPointCount)

	TEST (PathTessellatorTest, LinearCubicToPointCount)

	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)

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

static std::shared_ptr< GlyphAtlas >	CreateGlyphAtlas (Context &context, const TypographerContext *typographer_context, HostBuffer &host_buffer, GlyphAtlas::Type type, Rational scale, const std::shared_ptr< GlyphAtlasContext > &atlas_context, const std::vector< std::shared_ptr< TextFrame >> &frames, const std::vector< std::optional< 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)

	TEST_P (TypographerTest, TextFrameInitialBoundsArePlaceholder)

	TEST_P (TypographerTest, TextFrameInvalidationWithScale)

	TEST_P (TypographerTest, TextFrameAtlasGenerationTracksState)

	TEST_P (TypographerTest, InvalidAtlasForcesRepopulation)

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

static constexpr std::string_view	kFontFixture

static constexpr const size_t	kMagicFailingAllocation = 1024000 * 2

std::vector< Point >	golden_cubic_and_quad_points

Typedef Documentation

◆ AiksTest

using impeller::testing::AiksTest = typedef AiksPlayground

Definition at line 17 of file aiks_unittests.h.

◆ AllocatorMTLTest

using impeller::testing::AllocatorMTLTest = typedef PlaygroundTest

Definition at line 25 of file allocator_mtl_unittests.mm.

◆ BlitPassTest

using impeller::testing::BlitPassTest = typedef AiksTest

Definition at line 27 of file blit_pass_unittests.cc.

◆ ComputeTest

using impeller::testing::ComputeTest = typedef ComputePlaygroundTest

Definition at line 21 of file compute_unittests.cc.

◆ ContextMTLTest

using impeller::testing::ContextMTLTest = typedef PlaygroundTest

Definition at line 25 of file context_mtl_unittests.mm.

◆ DeviceBufferTest

using impeller::testing::DeviceBufferTest = typedef Playground

Definition at line 12 of file device_buffer_unittests.cc.

◆ DisplayListTest

using impeller::testing::DisplayListTest = typedef DlPlayground

Definition at line 43 of file dl_unittests.cc.

◆ DlPathReceiverMock

using impeller::testing::DlPathReceiverMock = typedef flutter::testing::DlPathReceiverMock

Definition at line 19 of file path_source_unittests.cc.

◆ DriverInfoVKTest

using impeller::testing::DriverInfoVKTest = typedef PlaygroundTest

Definition at line 14 of file driver_info_vk_unittests.cc.

◆ EntityPassTargetTest

using impeller::testing::EntityPassTargetTest = typedef EntityPlayground

Definition at line 16 of file entity_pass_target_unittests.cc.

◆ EntityTest

typedef EntityPlayground impeller::testing::EntityTest

Definition at line 19 of file tiled_texture_contents_unittests.cc.

◆ HostBufferTest

using impeller::testing::HostBufferTest = typedef EntityPlayground

Definition at line 24 of file host_buffer_unittests.cc.

◆ PipelineCacheDataVKPlaygroundTest

using impeller::testing::PipelineCacheDataVKPlaygroundTest = typedef PlaygroundTest

Definition at line 114 of file pipeline_cache_data_vk_unittests.cc.

◆ RendererTest

typedef PlaygroundTest impeller::testing::RendererTest

Definition at line 15 of file render_pass_cache_unittests.cc.

◆ RenderTargetCacheTest

using impeller::testing::RenderTargetCacheTest = typedef EntityPlayground

Definition at line 20 of file render_target_cache_unittests.cc.

◆ RuntimeStageTest

using impeller::testing::RuntimeStageTest = typedef RuntimeStagePlayground

Definition at line 26 of file runtime_stage_unittests.cc.

◆ SaveLayerUtilsTest

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

Definition at line 15 of file save_layer_utils_unittests.cc.

◆ SwapchainTransientsMTLTest

using impeller::testing::SwapchainTransientsMTLTest = typedef PlaygroundTest

Definition at line 24 of file swapchain_transients_mtl_unittests.mm.

◆ TextContentsTest

using impeller::testing::TextContentsTest = typedef PlaygroundTest

Definition at line 20 of file text_contents_unittests.cc.

◆ TypographerTest

using impeller::testing::TypographerTest = typedef PlaygroundTest

Definition at line 29 of file typographer_unittests.cc.

Function Documentation

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [1/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Conical )

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [2/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Linear )

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [3/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Radial )

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [4/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Sweep )

◆ BlendModeTest()

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

static

Save layer blending (top squares).
CPU blend modes (bottom squares).
Image blending (bottom images).

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

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

References impeller::Color::alpha, impeller::Color::Black(), impeller::Color::Blend(), impeller::Color::blue, impeller::Color::CornflowerBlue(), impeller::Color::green, impeller::AiksPlayground::ImGuiBegin(), impeller::Color::LimeGreen(), impeller::Color::red, impeller::Color::White(), impeller::Color::WithAlpha(), and x.

◆ CanBatchSubmitTest()

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

Definition at line 71 of file driver_info_vk_unittests.cc.

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

References impeller::WorkaroundsVK::batch_submit_command_buffer_timeout, and impeller::GetWorkaroundsFromDriverInfo().

Referenced by TEST().

◆ CanRenderConicalGradientWithDithering()

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

static

Definition at line 155 of file aiks_dl_gradient_unittests.cc.

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

References impeller::Playground::GetContentScale(), impeller::AiksPlayground::OpenPlaygroundHere(), impeller::Color::ToARGB(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by TEST_P().

◆ CanRenderLinearGradientWithDithering()

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

static

Definition at line 92 of file aiks_dl_gradient_unittests.cc.

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

References impeller::AiksPlayground::OpenPlaygroundHere().

Referenced by TEST_P().

◆ CanRenderRadialGradientWithDithering()

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

static

Definition at line 112 of file aiks_dl_gradient_unittests.cc.

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

References impeller::AiksPlayground::OpenPlaygroundHere(), and impeller::Color::ToARGB().

Referenced by TEST_P().

◆ CanRenderSweepGradientWithDithering()

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

static

Definition at line 132 of file aiks_dl_gradient_unittests.cc.

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

References impeller::Playground::GetContentScale(), impeller::AiksPlayground::OpenPlaygroundHere(), impeller::Color::ToARGB(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by TEST_P().

◆ CanUseFramebufferFetch()

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

Definition at line 197 of file driver_info_vk_unittests.cc.

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

References impeller::GetWorkaroundsFromDriverInfo(), and impeller::WorkaroundsVK::input_attachment_self_dependency_broken.

Referenced by TEST().

◆ CanUseMipgeneration()

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

Definition at line 127 of file driver_info_vk_unittests.cc.

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

References impeller::WorkaroundsVK::broken_mipmap_generation, and impeller::GetWorkaroundsFromDriverInfo().

Referenced by TEST().

◆ CanUsePrimitiveRestartSubmitTest()

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

Definition at line 98 of file driver_info_vk_unittests.cc.

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

References impeller::GetWorkaroundsFromDriverInfo(), and impeller::WorkaroundsVK::slow_primitive_restart_performance.

Referenced by TEST().

◆ CAPABILITY_TEST() [1/11]

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

◆ CAPABILITY_TEST() [2/11]

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

◆ CAPABILITY_TEST() [3/11]

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

◆ CAPABILITY_TEST() [4/11]

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

◆ CAPABILITY_TEST() [5/11]

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

◆ CAPABILITY_TEST() [6/11]

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

◆ CAPABILITY_TEST() [7/11]

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

◆ CAPABILITY_TEST() [8/11]

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

◆ CAPABILITY_TEST() [9/11]

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

◆ CAPABILITY_TEST() [10/11]

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

◆ CAPABILITY_TEST() [11/11]

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

◆ CompareFunctionUI()

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

static

Definition at line 1220 of file renderer_unittests.cc.

                                                         {
   static CompareFunctionUIData data;
   return data;
 }

References data.

Referenced by TEST_P().

◆ CreateDefaultPipeline()

template<class VertexShader , class FragmentShader >

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

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

References impeller::kCount4.

◆ CreateGlyphAtlas() [1/2]

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

static

Definition at line 32 of file typographer_unittests.cc.

                                            {
   frame->SetPerFrameData(scale, {0, 0}, Matrix(), std::nullopt);
   return typographer_context->CreateGlyphAtlas(context, type, host_buffer,
                                                atlas_context, {frame});
 }

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

Referenced by TEST_P().

◆ CreateGlyphAtlas() [2/2]

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

static

Definition at line 45 of file typographer_unittests.cc.

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

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

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

Referenced by TEST().

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

Referenced by TEST().

◆ CreateTestCanvas()

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

Definition at line 25 of file canvas_unittests.cc.

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

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

Referenced by TEST_P().

◆ CreateTestYUVTextures()

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

static

Definition at line 1657 of file entity_unittests.cc.

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

References impeller::DeviceBuffer::AsBufferView(), impeller::Context::CreateCommandBuffer(), impeller::TextureDescriptor::format, impeller::Context::GetCommandQueue(), impeller::Context::GetResourceAllocator(), impeller::kHostVisible, impeller::kR8G8UNormInt, impeller::kR8UNormInt, RGBToYUV(), impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

Referenced by TEST_P().

◆ DoGradientOvalStrokeMaskBlur()

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

Definition at line 62 of file aiks_dl_blur_unittests.cc.

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

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by TEST_P().

◆ flip_lr()

template<typename R >

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

inlinestaticconstexpr

Definition at line 1324 of file rect_unittests.cc.

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

Referenced by flip_lrtb(), and TEST().

◆ flip_lrtb()

template<typename R >

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

inlinestaticconstexpr

Definition at line 1336 of file rect_unittests.cc.

                                             {
   return flip_lr(flip_tb(rect));
 }

References flip_lr(), and flip_tb().

Referenced by TEST().

◆ flip_tb()

template<typename R >

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

inlinestaticconstexpr

Definition at line 1330 of file rect_unittests.cc.

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

Referenced by flip_lrtb(), and TEST().

◆ FML_TEST_CLASS() [1/2]

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

◆ FML_TEST_CLASS() [2/2]

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

◆ GetBlendModeSelection()

static BlendModeSelection impeller::testing::GetBlendModeSelection ( )

static

Definition at line 44 of file aiks_dl_blend_unittests.cc.

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

References BLEND_MODE_TUPLE, IMPELLER_FOR_EACH_BLEND_MODE, and impeller::Entity::kLastAdvancedBlendMode.

Referenced by TEST_P().

◆ INSTANTIATE_COMPUTE_SUITE()

impeller::testing::INSTANTIATE_COMPUTE_SUITE ( ComputeTest )

◆ INSTANTIATE_METAL_PLAYGROUND_SUITE()

impeller::testing::INSTANTIATE_METAL_PLAYGROUND_SUITE ( AllocatorMTLTest )

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

◆ INSTANTIATE_PLAYGROUND_SUITE() [4/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( GaussianBlurFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [5/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( HostBufferTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [6/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( MatrixFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [7/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RendererDartTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [8/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RuntimeStageTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [9/9]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( TextContentsTest )

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

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

◆ IsBadVersionTest()

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

Definition at line 53 of file driver_info_vk_unittests.cc.

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

Referenced by TEST().

◆ MaskBlurVariantTest()

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

static

Definition at line 505 of file aiks_dl_blur_unittests.cc.

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

References impeller::testing::MaskBlurTestConfig::alpha, impeller::Color::AntiqueWhite(), impeller::testing::MaskBlurTestConfig::blend_mode, impeller::Playground::GetContentScale(), impeller::testing::MaskBlurTestConfig::image_filter, impeller::testing::MaskBlurTestConfig::invert_colors, impeller::TRect< Scalar >::MakeXYWH(), impeller::testing::MaskBlurTestConfig::sigma, impeller::testing::MaskBlurTestConfig::style, x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ RectMakeCenterSize()

Rect impeller::testing::RectMakeCenterSize	(	Point	center,
		Size	size
	)

Definition at line 68 of file entity_unittests.cc.

                                                  {
   return Rect::MakeSize(size).Shift(center - size / 2);
 }

References impeller::TRect< Scalar >::MakeSize(), and impeller::TRect< T >::Shift().

Referenced by TEST_P().

◆ RenderTextInCanvasSkia()

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

Definition at line 44 of file aiks_dl_text_unittests.cc.

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

Referenced by TEST_P(), and flutter::testing::TEST_P().

◆ RGBToYUV()

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

static

Definition at line 1640 of file entity_unittests.cc.

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

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

Referenced by CreateTestYUVTextures().

◆ swap_nan() [1/2]

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

inlinestaticconstexpr

Definition at line 1350 of file rect_unittests.cc.

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

References x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ swap_nan() [2/2]

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

inlinestaticconstexpr

Definition at line 1340 of file rect_unittests.cc.

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

References impeller::saturated::b, impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), and impeller::TRect< Scalar >::MakeLTRB().

Referenced by TEST().

◆ TEST() [1/523]

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

Definition at line 77 of file allocation_size_unittests.cc.

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

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

◆ TEST() [2/523]

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

Definition at line 110 of file allocation_size_unittests.cc.

                                                 {
   {
     Bytes a(1u);
     ASSERT_EQ(a.GetByteSize(), 1u);
   }
   {
     Bytes a(1.5);
     ASSERT_EQ(a.GetByteSize(), 2u);
   }
   {
     Bytes a(1.5f);
     ASSERT_EQ(a.GetByteSize(), 2u);
   }
 }

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

◆ TEST() [3/523]

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

Definition at line 44 of file allocation_size_unittests.cc.

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

◆ TEST() [4/523]

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

Definition at line 10 of file allocation_size_unittests.cc.

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

References e3.

◆ TEST() [5/523]

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

Definition at line 33 of file allocation_size_unittests.cc.

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

References e3.

◆ TEST() [6/523]

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

Definition at line 55 of file allocation_size_unittests.cc.

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

◆ TEST() [7/523]

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

Definition at line 91 of file allocation_size_unittests.cc.

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

References impeller::saturated::b.

◆ TEST() [8/523]

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

Definition at line 49 of file allocation_size_unittests.cc.

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

◆ TEST() [9/523]

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

Definition at line 60 of file allocation_size_unittests.cc.

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

References impeller::saturated::b.

◆ TEST() [10/523]

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

Definition at line 82 of file allocator_unittests.cc.

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

References impeller::saturated::b, and impeller::Range::Merge().

◆ TEST() [11/523]

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

Definition at line 16 of file allocator_unittests.cc.

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

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

◆ TEST() [12/523]

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

Definition at line 77 of file allocator_vk_unittests.cc.

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

References impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, and impeller::TextureDescriptor::storage_mode.

◆ TEST() [13/523]

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

Definition at line 39 of file allocator_vk_unittests.cc.

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

References impeller::AllocatorVK::FindMemoryTypeIndex().

◆ TEST() [14/523]

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

Definition at line 54 of file allocator_vk_unittests.cc.

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

References impeller::AllocatorVK::FindMemoryTypeIndex().

◆ TEST() [15/523]

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

Definition at line 20 of file allocator_vk_unittests.cc.

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

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

◆ TEST() [16/523]

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

Definition at line 262 of file arc_unittests.cc.

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

◆ TEST() [17/523]

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

Definition at line 274 of file arc_unittests.cc.

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

◆ TEST() [18/523]

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

Definition at line 266 of file arc_unittests.cc.

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

◆ TEST() [19/523]

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

Definition at line 270 of file arc_unittests.cc.

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

◆ TEST() [20/523]

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

Definition at line 125 of file arc_unittests.cc.

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

References start.

◆ TEST() [21/523]

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

Definition at line 210 of file arc_unittests.cc.

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

◆ TEST() [22/523]

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

Definition at line 222 of file arc_unittests.cc.

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

◆ TEST() [23/523]

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

Definition at line 214 of file arc_unittests.cc.

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

◆ TEST() [24/523]

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

Definition at line 218 of file arc_unittests.cc.

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

◆ TEST() [25/523]

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

Definition at line 172 of file arc_unittests.cc.

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

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

◆ TEST() [26/523]

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

Definition at line 153 of file arc_unittests.cc.

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

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

◆ TEST() [27/523]

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

Definition at line 190 of file arc_unittests.cc.

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

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

◆ TEST() [28/523]

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

Definition at line 264 of file base_unittests.cc.

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

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

◆ TEST() [29/523]

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

Definition at line 255 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() [30/523]

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

Definition at line 248 of file base_unittests.cc.

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

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

◆ TEST() [31/523]

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

Definition at line 51 of file buffer_bindings_gles_unittests.cc.

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

References impeller::BufferBindingsGLES::BindUniformData(), buffer_view, impeller::kFloat, impeller::ShaderMetadata::name, impeller::DeviceBufferDescriptor::size, and impeller::ShaderStructMemberMetadata::type.

◆ TEST() [32/523]

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

Definition at line 17 of file buffer_bindings_gles_unittests.cc.

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

References impeller::BufferBindingsGLES::BindUniformData(), buffer_view, impeller::kFloat, impeller::ShaderMetadata::name, impeller::DeviceBufferDescriptor::size, and impeller::ShaderStructMemberMetadata::type.

◆ TEST() [33/523]

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

Definition at line 11 of file buffer_view_unittests.cc.

                             {
   BufferView buffer_view;
   EXPECT_FALSE(buffer_view);
 }

References buffer_view.

◆ TEST() [34/523]

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

Definition at line 16 of file buffer_view_unittests.cc.

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

References buffer_view.

◆ TEST() [35/523]

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

Definition at line 33 of file capabilities_unittests.cc.

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

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

◆ TEST() [36/523]

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

Definition at line 51 of file capabilities_unittests.cc.

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

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

◆ TEST() [37/523]

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

Definition at line 61 of file capabilities_unittests.cc.

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

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

◆ TEST() [38/523]

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

Definition at line 42 of file capabilities_unittests.cc.

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

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

◆ TEST() [39/523]

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

Definition at line 70 of file capabilities_unittests.cc.

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

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

◆ TEST() [40/523]

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

Definition at line 79 of file capabilities_unittests.cc.

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

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

◆ TEST() [41/523]

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

Definition at line 215 of file context_vk_unittests.cc.

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

◆ TEST() [42/523]

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

Definition at line 184 of file context_vk_unittests.cc.

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

References impeller::CapabilitiesVK::GetDefaultDepthStencilFormat(), impeller::CapabilitiesVK::GetDefaultStencilFormat(), and impeller::kD32FloatS8UInt.

◆ TEST() [43/523]

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

Definition at line 37 of file command_encoder_vk_unittests.cc.

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

References impeller::CommandBuffer::kCompleted.

◆ TEST() [44/523]

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

Definition at line 15 of file command_encoder_vk_unittests.cc.

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

◆ TEST() [45/523]

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

Definition at line 137 of file command_pool_vk_unittests.cc.

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

◆ TEST() [46/523]

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

Definition at line 178 of file command_pool_vk_unittests.cc.

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

◆ TEST() [47/523]

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() [48/523]

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() [49/523]

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

Definition at line 107 of file command_pool_vk_unittests.cc.

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

◆ TEST() [50/523]

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

Definition at line 222 of file command_pool_vk_unittests.cc.

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

References impeller::CommandPoolRecyclerVK::GetGlobalPoolCount().

◆ TEST() [51/523]

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

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

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

◆ TEST() [52/523]

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

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

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

◆ TEST() [53/523]

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

Definition at line 120 of file base_unittests.cc.

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

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

◆ TEST() [54/523]

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

Definition at line 141 of file base_unittests.cc.

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

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

◆ TEST() [55/523]

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

Definition at line 97 of file base_unittests.cc.

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

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

◆ TEST() [56/523]

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

Definition at line 357 of file context_vk_unittests.cc.

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

References data, and impeller::ContextVK::Settings::enable_surface_control.

◆ TEST() [57/523]

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

Definition at line 306 of file context_vk_unittests.cc.

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

◆ TEST() [58/523]

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

Definition at line 335 of file context_vk_unittests.cc.

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

◆ TEST() [59/523]

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

Definition at line 152 of file context_vk_unittests.cc.

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

References impeller::CapabilitiesVK::AreValidationsEnabled().

◆ TEST() [60/523]

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

Definition at line 166 of file context_vk_unittests.cc.

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

References impeller::CapabilitiesVK::AreValidationsEnabled().

◆ TEST() [61/523]

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

Definition at line 17 of file context_vk_unittests.cc.

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

References impeller::ContextVK::ChooseThreadCountForWorkers().

◆ TEST() [62/523]

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

Definition at line 95 of file context_vk_unittests.cc.

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

References impeller::PipelineFuture< T >::Get(), and impeller::PipelineDescriptor::SetVertexDescriptor().

◆ TEST() [63/523]

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

Definition at line 136 of file context_vk_unittests.cc.

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

References impeller::PipelineDescriptor::SetVertexDescriptor().

◆ TEST() [64/523]

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

Definition at line 30 of file context_vk_unittests.cc.

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

◆ TEST() [65/523]

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

Definition at line 45 of file context_vk_unittests.cc.

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

◆ TEST() [66/523]

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

Definition at line 114 of file context_vk_unittests.cc.

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

References data, impeller::kFragment, and impeller::PipelineDescriptor::SetVertexDescriptor().

◆ TEST() [67/523]

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

Definition at line 283 of file context_vk_unittests.cc.

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

References data.

◆ TEST() [68/523]

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

Definition at line 264 of file context_vk_unittests.cc.

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

References data.

◆ TEST() [69/523]

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

Definition at line 245 of file context_vk_unittests.cc.

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

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

◆ TEST() [70/523]

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

Definition at line 256 of file context_vk_unittests.cc.

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

References impeller::CapabilitiesVK::GetDefaultColorFormat(), and impeller::kUnknown.

◆ TEST() [71/523]

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

Definition at line 395 of file context_vk_unittests.cc.

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

◆ TEST() [72/523]

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

Definition at line 76 of file context_vk_unittests.cc.

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

◆ TEST() [73/523]

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

Definition at line 234 of file context_vk_unittests.cc.

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

References impeller::kR8G8B8A8UNormInt.

◆ TEST() [74/523]

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

Definition at line 110 of file descriptor_pool_vk_unittests.cc.

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

References impeller::DescriptorPoolVK::AllocateDescriptorSets().

◆ TEST() [75/523]

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

Definition at line 13 of file descriptor_pool_vk_unittests.cc.

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

◆ TEST() [76/523]

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

Definition at line 88 of file descriptor_pool_vk_unittests.cc.

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

References impeller::BackendCast< CommandBufferVK, CommandBuffer >::Cast(), and impeller::CommandBufferVK::GetDescriptorPool().

◆ TEST() [77/523]

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

Definition at line 46 of file descriptor_pool_vk_unittests.cc.

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

◆ TEST() [78/523]

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

Definition at line 25 of file descriptor_pool_vk_unittests.cc.

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

References impeller::DescriptorPoolVK::AllocateDescriptorSets().

◆ TEST() [79/523]

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

Definition at line 25 of file device_buffer_gles_unittests.cc.

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

References impeller::DeviceBufferGLES::kUniformBuffer, and impeller::DeviceBufferDescriptor::size.

◆ TEST() [80/523]

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

Definition at line 89 of file draw_order_resolver_unittests.cc.

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

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

◆ TEST() [81/523]

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

Definition at line 33 of file draw_order_resolver_unittests.cc.

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

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

◆ TEST() [82/523]

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

Definition at line 114 of file draw_order_resolver_unittests.cc.

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

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

◆ TEST() [83/523]

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

Definition at line 12 of file draw_order_resolver_unittests.cc.

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

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

◆ TEST() [84/523]

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

Definition at line 90 of file driver_info_vk_unittests.cc.

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

References CanBatchSubmitTest().

◆ TEST() [85/523]

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

Definition at line 146 of file driver_info_vk_unittests.cc.

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

References CanUseMipgeneration().

◆ TEST() [86/523]

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

Definition at line 40 of file driver_info_vk_unittests.cc.

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

◆ TEST() [87/523]

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

Definition at line 216 of file driver_info_vk_unittests.cc.

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

References CanUseFramebufferFetch().

◆ TEST() [88/523]

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

Definition at line 118 of file driver_info_vk_unittests.cc.

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

References CanUsePrimitiveRestartSubmitTest().

◆ TEST() [89/523]

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

Definition at line 166 of file driver_info_vk_unittests.cc.

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

References IsBadVersionTest().

◆ TEST() [90/523]

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

Definition at line 226 of file driver_info_vk_unittests.cc.

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

◆ TEST() [91/523]

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

Definition at line 161 of file driver_info_vk_unittests.cc.

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

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

◆ TEST() [92/523]

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

Definition at line 155 of file driver_info_vk_unittests.cc.

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

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

◆ TEST() [93/523]

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

Definition at line 186 of file driver_info_vk_unittests.cc.

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

References IsBadVersionTest().

◆ TEST() [94/523]

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

Definition at line 181 of file driver_info_vk_unittests.cc.

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

References IsBadVersionTest().

◆ TEST() [95/523]

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

Definition at line 271 of file driver_info_vk_unittests.cc.

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

References impeller::GetWorkaroundsFromDriverInfo(), impeller::WorkaroundsVK::input_attachment_self_dependency_broken, and impeller::kDXT.

◆ TEST() [96/523]

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

Definition at line 254 of file driver_info_vk_unittests.cc.

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

References impeller::kUnknown.

◆ TEST() [97/523]

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

Definition at line 543 of file geometry_unittests.cc.

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

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

◆ TEST() [98/523]

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

Definition at line 104 of file geometry_unittests.cc.

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

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

◆ TEST() [99/523]

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

Definition at line 81 of file geometry_unittests.cc.

                                                      {
   auto path = flutter::DlPathBuilder{}
                   .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                   .TakePath();
   auto geometry = Geometry::MakeFillPath(
       path, /* inner rect */ Rect::MakeLTRB(0, 0, 100, 100));
   ASSERT_TRUE(geometry->CoversArea({}, 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()));
 }

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

◆ TEST() [100/523]

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

Definition at line 93 of file geometry_unittests.cc.

                                                                 {
   auto path = flutter::DlPathBuilder{}
                   .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                   .TakePath();
   auto geometry = Geometry::MakeFillPath(path);
   ASSERT_FALSE(geometry->CoversArea({}, 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()));
 }

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

◆ TEST() [101/523]

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

Definition at line 471 of file geometry_unittests.cc.

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

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

◆ TEST() [102/523]

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

Definition at line 536 of file geometry_unittests.cc.

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

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

◆ TEST() [103/523]

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

Definition at line 497 of file geometry_unittests.cc.

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

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

◆ TEST() [104/523]

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

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

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

◆ TEST() [105/523]

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

Definition at line 1315 of file geometry_unittests.cc.

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

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

◆ TEST() [106/523]

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

Definition at line 1332 of file geometry_unittests.cc.

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

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

◆ TEST() [107/523]

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

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

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

◆ TEST() [108/523]

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

Definition at line 568 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, and points.

◆ TEST() [109/523]

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

Definition at line 609 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kPiOver2, impeller::kRound, points, and impeller::Radians::radians.

◆ TEST() [110/523]

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

Definition at line 697 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, and points.

◆ TEST() [111/523]

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

Definition at line 270 of file geometry_unittests.cc.

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

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

◆ TEST() [112/523]

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

Definition at line 1180 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, and impeller::kRound.

◆ TEST() [113/523]

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

Definition at line 1247 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, and impeller::kRound.

◆ TEST() [114/523]

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

Definition at line 1113 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, and impeller::kRound.

◆ TEST() [115/523]

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

Definition at line 927 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, and points.

◆ TEST() [116/523]

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

Definition at line 964 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, and points.

◆ TEST() [117/523]

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

Definition at line 890 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, and points.

◆ TEST() [118/523]

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

Definition at line 1065 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, and impeller::kRound.

◆ TEST() [119/523]

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

Definition at line 782 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, and points.

◆ TEST() [120/523]

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

Definition at line 853 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kButt, impeller::kMiter, and points.

◆ TEST() [121/523]

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

Definition at line 1001 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::TPoint< T >::GetDistance(), impeller::kButt, impeller::kMiter, and impeller::Radians::radians.

◆ TEST() [122/523]

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

Definition at line 748 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, and points.

◆ TEST() [123/523]

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

Definition at line 816 of file geometry_unittests.cc.

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

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kButt, impeller::kMiter, and points.

◆ TEST() [124/523]

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

Definition at line 58 of file clip_stack_unittests.cc.

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

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

◆ TEST() [125/523]

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

Definition at line 88 of file clip_stack_unittests.cc.

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

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

◆ TEST() [126/523]

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

Definition at line 171 of file clip_stack_unittests.cc.

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

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

◆ TEST() [127/523]

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

Definition at line 193 of file clip_stack_unittests.cc.

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

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

◆ TEST() [128/523]

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

Definition at line 120 of file clip_stack_unittests.cc.

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

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

◆ TEST() [129/523]

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

Definition at line 146 of file clip_stack_unittests.cc.

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

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

◆ TEST() [130/523]

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

Definition at line 48 of file clip_stack_unittests.cc.

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

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

◆ TEST() [131/523]

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

Definition at line 14 of file clip_stack_unittests.cc.

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

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

◆ TEST() [132/523]

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

Definition at line 232 of file clip_stack_unittests.cc.

                                                            {
   EntityPassClipStack recorder =
       EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
  
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  
   // Push a clip.
   {
     EntityPassClipStack::ClipStateResult result =
         recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.5, 55.5),
                                          /*is_axis_aligned_rect=*/true),
                             Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
  
     EXPECT_TRUE(result.should_render);
     EXPECT_TRUE(result.clip_did_change);
   }
  
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 2u);
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
             Rect::MakeLTRB(50, 50, 55.5, 55.5));
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
   EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
  
   // Begin a subpass.
   recorder.PushSubpass(Rect::MakeLTRB(50, 50, 55, 55), 1);
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
   EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
             Rect::MakeLTRB(50, 50, 55, 55));
  
   {
     EntityPassClipStack::ClipStateResult result =
         recorder.RecordClip(ClipContents(Rect::MakeLTRB(54, 54, 54.5, 54.5),
                                          /*is_axis_aligned_rect=*/true),
                             Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
  
     EXPECT_TRUE(result.should_render);
     EXPECT_TRUE(result.clip_did_change);
   }
  
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
             Rect::MakeLTRB(54, 54, 54.5, 54.5));
  
   // End subpass.
   recorder.PopSubpass();
  
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
             Rect::MakeLTRB(50, 50, 55.5, 55.5));
 }

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

◆ TEST() [133/523]

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

Definition at line 281 of file clip_stack_unittests.cc.

                                                                 {
   EntityPassClipStack recorder =
       EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
  
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  
   // Push a clip.
   {
     EntityPassClipStack::ClipStateResult result =
         recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.4, 55.4),
                                          /*is_axis_aligned_rect=*/true),
                             Matrix(), {0, 0}, 0, 100, /*is_aa=*/false);
  
     EXPECT_FALSE(result.should_render);
     EXPECT_TRUE(result.clip_did_change);
   }
  
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 2u);
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
             Rect::MakeLTRB(50, 50, 55.0, 55.0));
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
   EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
  
   // Begin a subpass.
   recorder.PushSubpass(Rect::MakeLTRB(50, 50, 55, 55), 1);
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
   EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
             Rect::MakeLTRB(50, 50, 55, 55));
  
   {
     EntityPassClipStack::ClipStateResult result =
         recorder.RecordClip(ClipContents(Rect::MakeLTRB(54, 54, 55.4, 55.4),
                                          /*is_axis_aligned_rect=*/true),
                             Matrix(), {0, 0}, 0, 100, /*is_aa=*/false);
  
     EXPECT_FALSE(result.should_render);
     EXPECT_TRUE(result.clip_did_change);
   }
  
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
             Rect::MakeLTRB(54, 54, 55.0, 55.0));
  
   // End subpass.
   recorder.PopSubpass();
  
   EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
             Rect::MakeLTRB(50, 50, 55, 55));
 }

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

◆ TEST() [134/523]

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

Definition at line 213 of file clip_stack_unittests.cc.

                                                  {
   EntityPassClipStack recorder =
       EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
  
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  
   // Restore the clip.
   EntityPassClipStack::ClipStateResult result =
       recorder.RecordRestore(Point(0, 0), 0);
   EXPECT_FALSE(result.should_render);
   EXPECT_FALSE(result.clip_did_change);
  
   ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
   EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
             Rect::MakeSize(Size::MakeWH(100, 100)));
   EXPECT_EQ(recorder.GetClipCoverageLayers()[0].clip_height, 0u);
   EXPECT_EQ(recorder.GetReplayEntities().size(), 0u);
 }

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

◆ TEST() [135/523]

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

References value.

◆ TEST() [136/523]

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

References value.

◆ TEST() [137/523]

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

References value.

◆ TEST() [138/523]

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

References value.

◆ TEST() [139/523]

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

References value.

◆ TEST() [140/523]

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() [141/523]

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(); });
  
   // Signal the fence after a delay.
   std::thread thread([&]() {
     std::this_thread::sleep_for(std::chrono::milliseconds{100u});
     raw_fence->SetStatus(vk::Result::eSuccess);
   });
  
   // Terminate the waiter.  This will block until all pending fences are
   // signalled.
   waiter->Terminate();
  
   // This will hang if the fence was not signalled.
   signal.Wait();
  
   thread.join();
 }

References value.

◆ TEST() [142/523]

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

Definition at line 15 of file filter_input_unittests.cc.

                                                       {
   std::shared_ptr<Texture> texture = nullptr;
   auto input =
       FilterInput::Make(texture, Matrix::MakeTranslation({1.0, 0.0, 0.0}));
   Entity e;
   e.SetTransform(Matrix::MakeTranslation({0.0, 2.0, 0.0}));
  
   ASSERT_MATRIX_NEAR(input->GetLocalTransform(e),
                      Matrix::MakeTranslation({1.0, 0.0, 0.0}));
   ASSERT_MATRIX_NEAR(input->GetTransform(e),
                      Matrix::MakeTranslation({1.0, 2.0, 0.0}));
 }

References ASSERT_MATRIX_NEAR, impeller::FilterInput::Make(), impeller::Matrix::MakeTranslation(), and impeller::Entity::SetTransform().

◆ TEST() [143/523]

impeller::testing::TEST	(	FormatsVKTest	,
		DescriptorMapping
	)

Definition at line 11 of file formats_vk_unittests.cc.

                                        {
   EXPECT_EQ(ToVKDescriptorType(DescriptorType::kSampledImage),
             vk::DescriptorType::eCombinedImageSampler);
   EXPECT_EQ(ToVKDescriptorType(DescriptorType::kUniformBuffer),
             vk::DescriptorType::eUniformBuffer);
   EXPECT_EQ(ToVKDescriptorType(DescriptorType::kStorageBuffer),
             vk::DescriptorType::eStorageBuffer);
   EXPECT_EQ(ToVKDescriptorType(DescriptorType::kImage),
             vk::DescriptorType::eSampledImage);
   EXPECT_EQ(ToVKDescriptorType(DescriptorType::kSampler),
             vk::DescriptorType::eSampler);
   EXPECT_EQ(ToVKDescriptorType(DescriptorType::kInputAttachment),
             vk::DescriptorType::eInputAttachment);
 }

References impeller::kImage, impeller::kInputAttachment, impeller::kSampledImage, impeller::kSampler, impeller::kStorageBuffer, impeller::kUniformBuffer, and impeller::ToVKDescriptorType().

◆ TEST() [144/523]

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

Definition at line 458 of file gaussian_blur_filter_contents_unittests.cc.

                                                                   {
   Scalar sigma = 1.0;
   Scalar radius = GaussianBlurFilterContents::CalculateBlurRadius(
       GaussianBlurFilterContents::ScaleSigma(sigma));
   fml::StatusOr<Scalar> derived_sigma =
       CalculateSigmaForBlurRadius(radius, Matrix());
   ASSERT_TRUE(derived_sigma.ok());
   EXPECT_NEAR(sigma, derived_sigma.value(), 0.01f);
 }

References impeller::GaussianBlurFilterContents::CalculateBlurRadius(), and impeller::GaussianBlurFilterContents::ScaleSigma().

◆ TEST() [145/523]

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

Definition at line 225 of file gaussian_blur_filter_contents_unittests.cc.

                                                            {
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(1.0f), 1);
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(2.0f), 1);
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(3.0f), 1);
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(4.0f), 1);
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(16.0f), 0.25);
   // Hang on to 1/8 as long as possible.
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(95.0f), 0.125);
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(96.0f), 0.0625);
   // Downsample clamped to 1/16th.
   EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(1024.0f), 0.0625);
 }

References impeller::GaussianBlurFilterContents::CalculateScale().

◆ TEST() [146/523]

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

Definition at line 621 of file gaussian_blur_filter_contents_unittests.cc.

                                                     {
   Scalar sigma = 30.5f;
   int32_t blur_radius = static_cast<int32_t>(
       std::ceil(GaussianBlurFilterContents::CalculateBlurRadius(sigma)));
   BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
                                .blur_sigma = sigma,
                                .blur_radius = blur_radius,
                                .step_size = 1};
   KernelSamples kernel_samples = GenerateBlurInfo(parameters);
   GaussianBlurPipeline::FragmentShader::KernelSamples frag_kernel_samples =
       LerpHackKernelSamples(kernel_samples);
   EXPECT_TRUE(frag_kernel_samples.sample_count <= kGaussianBlurMaxKernelSize);
 }

References blur_radius, impeller::BlurParameters::blur_uv_offset, impeller::GaussianBlurFilterContents::CalculateBlurRadius(), impeller::GenerateBlurInfo(), impeller::kGaussianBlurMaxKernelSize, and impeller::LerpHackKernelSamples().

◆ TEST() [147/523]

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

Definition at line 468 of file gaussian_blur_filter_contents_unittests.cc.

                                                    {
   BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
                                .blur_sigma = 1,
                                .blur_radius = 5,
                                .step_size = 1};
   KernelSamples samples = GenerateBlurInfo(parameters);
   EXPECT_EQ(samples.sample_count, 11);
  
   // Coefficients should add up to 1.
   Scalar tally = 0;
   for (int i = 0; i < samples.sample_count; ++i) {
     tally += samples.samples[i].coefficient;
   }
   EXPECT_FLOAT_EQ(tally, 1.0f);
  
   // Verify the shape of the curve.
   for (int i = 0; i < 4; ++i) {
     EXPECT_FLOAT_EQ(samples.samples[i].coefficient,
                     samples.samples[10 - i].coefficient);
     EXPECT_TRUE(samples.samples[i + 1].coefficient >
                 samples.samples[i].coefficient);
   }
 }

References impeller::BlurParameters::blur_uv_offset, impeller::KernelSample::coefficient, impeller::GenerateBlurInfo(), impeller::KernelSamples::sample_count, and impeller::KernelSamples::samples.

◆ TEST() [148/523]

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

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

References impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, and impeller::FilterContents::kNormal.

◆ TEST() [149/523]

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

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

References impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [150/523]

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

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

References EXPECT_RECT_NEAR, impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [151/523]

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

Definition at line 113 of file gaussian_blur_filter_contents_unittests.cc.

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

References impeller::GaussianBlurFilterContents::GetSigmaX(), impeller::GaussianBlurFilterContents::GetSigmaY(), impeller::Entity::kDecal, and impeller::FilterContents::kNormal.

◆ TEST() [152/523]

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

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

References EXPECT_RECT_NEAR, impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::TRect< Scalar >::MakeLTRB(), and impeller::Matrix::MakeScale().

◆ TEST() [153/523]

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

Definition at line 567 of file gaussian_blur_filter_contents_unittests.cc.

                                                                    {
   Scalar sigma = 10.0f;
   int32_t blur_radius = static_cast<int32_t>(
       std::ceil(GaussianBlurFilterContents::CalculateBlurRadius(sigma)));
   BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
                                .blur_sigma = sigma,
                                .blur_radius = blur_radius,
                                .step_size = 1};
   KernelSamples kernel_samples = GenerateBlurInfo(parameters);
   EXPECT_EQ(kernel_samples.sample_count, 33);
   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++) {
     fast_output += GetCoefficient(fast_kernel_samples.sample_data[i]) *
                    sampler(GetUVOffset(fast_kernel_samples.sample_data[i]));
   }
  
   EXPECT_NEAR(output, fast_output, 0.1);
 }

References blur_radius, impeller::BlurParameters::blur_uv_offset, impeller::GaussianBlurFilterContents::CalculateBlurRadius(), impeller::KernelSample::coefficient, data, impeller::GenerateBlurInfo(), IMPELLER_RAND, impeller::LerpHackKernelSamples(), impeller::KernelSamples::sample_count, and impeller::KernelSamples::samples.

◆ TEST() [154/523]

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

Definition at line 492 of file gaussian_blur_filter_contents_unittests.cc.

                                                                   {
   KernelSamples kernel_samples = {
       .sample_count = 5,
       .samples =
           {
               {
                   .uv_offset = Vector2(-2, 0),
                   .coefficient = 0.1f,
               },
               {
                   .uv_offset = Vector2(-1, 0),
                   .coefficient = 0.2f,
               },
               {
                   .uv_offset = Vector2(0, 0),
                   .coefficient = 0.4f,
               },
               {
                   .uv_offset = Vector2(1, 0),
                   .coefficient = 0.2f,
               },
               {
                   .uv_offset = Vector2(2, 0),
                   .coefficient = 0.1f,
               },
           },
   };
  
   GaussianBlurPipeline::FragmentShader::KernelSamples blur_info =
       LerpHackKernelSamples(kernel_samples);
   EXPECT_EQ(blur_info.sample_count, 3);
  
   KernelSample* samples = kernel_samples.samples;
  
   //////////////////////////////////////////////////////////////////////////////
   // Check output kernel.
  
   EXPECT_POINT_NEAR(GetUVOffset(blur_info.sample_data[0]),
                     Point(-1.3333333, 0));
   EXPECT_FLOAT_EQ(GetCoefficient(blur_info.sample_data[0]), 0.3);
  
   EXPECT_POINT_NEAR(GetUVOffset(blur_info.sample_data[1]), Point(0, 0));
   EXPECT_FLOAT_EQ(GetCoefficient(blur_info.sample_data[1]), 0.4);
  
   EXPECT_POINT_NEAR(GetUVOffset(blur_info.sample_data[2]), Point(1.333333, 0));
   EXPECT_FLOAT_EQ(GetCoefficient(blur_info.sample_data[2]), 0.3);
  
   //////////////////////////////////////////////////////////////////////////////
   // Check output of fast kernel versus original kernel.
  
   Scalar data[5] = {0.25, 0.5, 0.5, 1.0, 0.2};
   Scalar original_output =
       samples[0].coefficient * data[0] + samples[1].coefficient * data[1] +
       samples[2].coefficient * data[2] + samples[3].coefficient * data[3] +
       samples[4].coefficient * data[4];
  
   auto lerp = [](const Point& point, Scalar left, Scalar right) {
     Scalar int_part;
     Scalar fract = fabsf(modf(point.x, &int_part));
     if (point.x < 0) {
       return left * fract + right * (1.0 - fract);
     } else {
       return left * (1.0 - fract) + right * fract;
     }
   };
   Scalar fast_output =
       /*1st*/ lerp(GetUVOffset(blur_info.sample_data[0]), data[0], data[1]) *
           GetCoefficient(blur_info.sample_data[0]) +
       /*2nd*/ data[2] * GetCoefficient(blur_info.sample_data[1]) +
       /*3rd*/ lerp(GetUVOffset(blur_info.sample_data[2]), data[3], data[4]) *
           GetCoefficient(blur_info.sample_data[2]);
  
   EXPECT_NEAR(original_output, fast_output, 0.01);
 }

References impeller::KernelSample::coefficient, data, EXPECT_POINT_NEAR, impeller::LerpHackKernelSamples(), impeller::KernelSamples::sample_count, impeller::KernelSamples::samples, and impeller::TPoint< T >::x.

◆ TEST() [155/523]

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

Definition at line 1709 of file geometry_unittests.cc.

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

References _BLEND_MODE_NAME_CHECK, impeller::BlendModeToString(), IMPELLER_FOR_EACH_BLEND_MODE, and impeller::kLastMode.

◆ TEST() [156/523]

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

Definition at line 1718 of file geometry_unittests.cc.

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

References impeller::kPiOver2, and impeller::Radians::radians.

◆ TEST() [157/523]

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

Definition at line 593 of file geometry_unittests.cc.

                                                {
   {
     Point p1(1.0, 2.0);
     IPoint p2 = static_cast<IPoint>(p1);
     ASSERT_EQ(p2.x, 1u);
     ASSERT_EQ(p2.y, 2u);
   }
  
   {
     Size s1(1.0, 2.0);
     ISize s2 = static_cast<ISize>(s1);
     ASSERT_EQ(s2.width, 1u);
     ASSERT_EQ(s2.height, 2u);
   }
  
   {
     Size s1(1.0, 2.0);
     Point p1 = static_cast<Point>(s1);
     ASSERT_EQ(p1.x, 1u);
     ASSERT_EQ(p1.y, 2u);
   }
 }

References impeller::TSize< T >::height, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [158/523]

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

Definition at line 580 of file geometry_unittests.cc.

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

References impeller::TSize< T >::MipCount().

◆ TEST() [159/523]

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

Definition at line 616 of file geometry_unittests.cc.

                                                 {
   {
     IPoint p1(1, 2);
     IPoint p2 = p1 + IPoint(1, 2);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(3, 6);
     IPoint p2 = p1 - IPoint(1, 2);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(1, 2);
     IPoint p2 = p1 * IPoint(2, 3);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 6u);
   }
  
   {
     IPoint p1(2, 6);
     IPoint p2 = p1 / IPoint(2, 3);
     ASSERT_EQ(p2.x, 1u);
     ASSERT_EQ(p2.y, 2u);
   }
 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [160/523]

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

Definition at line 646 of file geometry_unittests.cc.

                                                                    {
   // LHS
   {
     IPoint p1(1, 2);
     IPoint p2 = p1 * 2.0f;
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(2, 6);
     IPoint p2 = p1 / 2.0f;
     ASSERT_EQ(p2.x, 1u);
     ASSERT_EQ(p2.y, 3u);
   }
  
   // RHS
   {
     IPoint p1(1, 2);
     IPoint p2 = 2.0f * p1;
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(2, 6);
     IPoint p2 = 12.0f / p1;
     ASSERT_EQ(p2.x, 6u);
     ASSERT_EQ(p2.y, 2u);
   }
 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [161/523]

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

Definition at line 1276 of file geometry_unittests.cc.

                                                   {
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = p1 + Vector3(1, 2, 3);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
     ASSERT_EQ(p2.z, 6u);
   }
  
   {
     Vector3 p1(3, 6, 9);
     Vector3 p2 = p1 - Vector3(1, 2, 3);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
     ASSERT_EQ(p2.z, 6u);
   }
  
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = p1 * Vector3(2, 3, 4);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 6u);
     ASSERT_EQ(p2.z, 12u);
   }
  
   {
     Vector3 p1(2, 6, 12);
     Vector3 p2 = p1 / Vector3(2, 3, 4);
     ASSERT_EQ(p2.x, 1u);
     ASSERT_EQ(p2.y, 2u);
     ASSERT_EQ(p2.z, 3u);
   }
 }

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

◆ TEST() [162/523]

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

Definition at line 1310 of file geometry_unittests.cc.

                                                                      {
   // LHS
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = p1 + 2.0f;
     ASSERT_EQ(p2.x, 3);
     ASSERT_EQ(p2.y, 4);
     ASSERT_EQ(p2.z, 5);
   }
  
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = p1 - 2.0f;
     ASSERT_EQ(p2.x, -1);
     ASSERT_EQ(p2.y, 0);
     ASSERT_EQ(p2.z, 1);
   }
  
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = p1 * 2.0f;
     ASSERT_EQ(p2.x, 2);
     ASSERT_EQ(p2.y, 4);
     ASSERT_EQ(p2.z, 6);
   }
  
   {
     Vector3 p1(2, 6, 12);
     Vector3 p2 = p1 / 2.0f;
     ASSERT_EQ(p2.x, 1);
     ASSERT_EQ(p2.y, 3);
     ASSERT_EQ(p2.z, 6);
   }
  
   // RHS
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = 2.0f + p1;
     ASSERT_EQ(p2.x, 3);
     ASSERT_EQ(p2.y, 4);
     ASSERT_EQ(p2.z, 5);
   }
  
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = 2.0f - p1;
     ASSERT_EQ(p2.x, 1);
     ASSERT_EQ(p2.y, 0);
     ASSERT_EQ(p2.z, -1);
   }
  
   {
     Vector3 p1(1, 2, 3);
     Vector3 p2 = 2.0f * p1;
     ASSERT_EQ(p2.x, 2);
     ASSERT_EQ(p2.y, 4);
     ASSERT_EQ(p2.z, 6);
   }
  
   {
     Vector3 p1(2, 6, 12);
     Vector3 p2 = 12.0f / p1;
     ASSERT_EQ(p2.x, 6);
     ASSERT_EQ(p2.y, 2);
     ASSERT_EQ(p2.z, 1);
   }
 }

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

◆ TEST() [163/523]

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

Definition at line 798 of file geometry_unittests.cc.

                                                    {
   // Point on RHS
   {
     IPoint p(1, 2);
     p += IPoint(1, 2);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
   }
  
   {
     IPoint p(3, 6);
     p -= IPoint(1, 2);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
   }
  
   {
     IPoint p(1, 2);
     p *= IPoint(2, 3);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 6u);
   }
  
   {
     IPoint p(2, 6);
     p /= IPoint(2, 3);
     ASSERT_EQ(p.x, 1u);
     ASSERT_EQ(p.y, 2u);
   }
  
   // Size on RHS
   {
     IPoint p(1, 2);
     p += ISize(1, 2);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
   }
  
   {
     IPoint p(3, 6);
     p -= ISize(1, 2);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
   }
  
   {
     IPoint p(1, 2);
     p *= ISize(2, 3);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 6u);
   }
  
   {
     IPoint p(2, 6);
     p /= ISize(2, 3);
     ASSERT_EQ(p.x, 1u);
     ASSERT_EQ(p.y, 2u);
   }
  
   // Arithmetic type on RHS
   {
     IPoint p(1, 2);
     p *= 3;
     ASSERT_EQ(p.x, 3u);
     ASSERT_EQ(p.y, 6u);
   }
  
   {
     IPoint p(3, 6);
     p /= 3;
     ASSERT_EQ(p.x, 1u);
     ASSERT_EQ(p.y, 2u);
   }
 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [164/523]

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

Definition at line 1226 of file geometry_unittests.cc.

                                                      {
   {
     Vector3 p(1, 2, 4);
     p += Vector3(1, 2, 4);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
     ASSERT_EQ(p.z, 8u);
   }
  
   {
     Vector3 p(3, 6, 8);
     p -= Vector3(1, 2, 3);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
     ASSERT_EQ(p.z, 5u);
   }
  
   {
     Vector3 p(1, 2, 3);
     p *= Vector3(2, 3, 4);
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 6u);
     ASSERT_EQ(p.z, 12u);
   }
  
   {
     Vector3 p(1, 2, 3);
     p *= 2;
     ASSERT_EQ(p.x, 2u);
     ASSERT_EQ(p.y, 4u);
     ASSERT_EQ(p.z, 6u);
   }
  
   {
     Vector3 p(2, 6, 12);
     p /= Vector3(2, 3, 4);
     ASSERT_EQ(p.x, 1u);
     ASSERT_EQ(p.y, 2u);
     ASSERT_EQ(p.z, 3u);
   }
  
   {
     Vector3 p(2, 6, 12);
     p /= 2;
     ASSERT_EQ(p.x, 1u);
     ASSERT_EQ(p.y, 3u);
     ASSERT_EQ(p.z, 6u);
   }
 }

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

◆ TEST() [165/523]

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

Definition at line 1483 of file geometry_unittests.cc.

                                           {
   {
     ColorMatrix color_matrix = {
         1, 1, 1, 1, 1,  //
         1, 1, 1, 1, 1,  //
         1, 1, 1, 1, 1,  //
         1, 1, 1, 1, 1,  //
     };
     auto result = Color::White().ApplyColorMatrix(color_matrix);
     auto expected = Color(1, 1, 1, 1);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     ColorMatrix color_matrix = {
         0.1, 0,   0,   0,   0.01,  //
         0,   0.2, 0,   0,   0.02,  //
         0,   0,   0.3, 0,   0.03,  //
         0,   0,   0,   0.4, 0.04,  //
     };
     auto result = Color::White().ApplyColorMatrix(color_matrix);
     auto expected = Color(0.11, 0.22, 0.33, 0.44);
     ASSERT_COLOR_NEAR(result, expected);
   }
 }

References impeller::Color::ApplyColorMatrix(), ASSERT_COLOR_NEAR, and impeller::Color::White().

◆ TEST() [166/523]

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

Definition at line 1692 of file geometry_unittests.cc.

                                                      {
   Color dst = ColorBlendTestData::kDestinationColor;
   for (size_t source_i = 0;
        source_i < sizeof(ColorBlendTestData::kSourceColors) / sizeof(Color);
        source_i++) {
     Color src = ColorBlendTestData::kSourceColors[source_i];
  
     Color expected;
     IMPELLER_FOR_EACH_BLEND_MODE(_BLEND_MODE_RESULT_CHECK)
   }
 }

References _BLEND_MODE_RESULT_CHECK, IMPELLER_FOR_EACH_BLEND_MODE, impeller::testing::ColorBlendTestData::kDestinationColor, and impeller::testing::ColorBlendTestData::kSourceColors.

◆ TEST() [167/523]

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

Definition at line 1443 of file geometry_unittests.cc.

                                  {
   {
     Color result = Color(0.5, 0.5, 0.5, 0.5).Clamp01();
     Color expected = Color(0.5, 0.5, 0.5, 0.5);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     Color result = Color(-1, -1, -1, -1).Clamp01();
     Color expected = Color(0, 0, 0, 0);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     Color result = Color(2, 2, 2, 2).Clamp01();
     Color expected = Color(1, 1, 1, 1);
     ASSERT_COLOR_NEAR(result, expected);
   }
 }

References ASSERT_COLOR_NEAR, and impeller::Color::Clamp01().

◆ TEST() [168/523]

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

Definition at line 1421 of file geometry_unittests.cc.

                               {
   {
     Color a(0.0, 0.0, 0.0, 0.0);
     Color b(1.0, 1.0, 1.0, 1.0);
  
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.5), Color(0.5, 0.5, 0.5, 0.5));
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.0), a);
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 1.0), b);
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.2), Color(0.2, 0.2, 0.2, 0.2));
   }
  
   {
     Color a(0.2, 0.4, 1.0, 0.5);
     Color b(0.4, 1.0, 0.2, 0.3);
  
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.5), Color(0.3, 0.7, 0.6, 0.4));
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.0), a);
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 1.0), b);
     ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.2), Color(0.24, 0.52, 0.84, 0.46));
   }
 }

References ASSERT_COLOR_NEAR, impeller::saturated::b, and impeller::Color::Lerp().

◆ TEST() [169/523]

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

Definition at line 1509 of file geometry_unittests.cc.

                                       {
   {
     auto result = Color::White().LinearToSRGB();
     auto expected = Color(1, 1, 1, 1);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     auto result = Color::BlackTransparent().LinearToSRGB();
     auto expected = Color(0, 0, 0, 0);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     auto result = Color(0.2, 0.4, 0.6, 0.8).LinearToSRGB();
     auto expected = Color(0.484529, 0.665185, 0.797738, 0.8);
     ASSERT_COLOR_NEAR(result, expected);
   }
 }

References ASSERT_COLOR_NEAR, impeller::Color::BlackTransparent(), impeller::Color::LinearToSRGB(), and impeller::Color::White().

◆ TEST() [170/523]

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

Definition at line 1463 of file geometry_unittests.cc.

                                    {
   {
     Color a = Color::MakeRGBA8(0, 0, 0, 0);
     Color b = Color::BlackTransparent();
     ASSERT_COLOR_NEAR(a, b);
   }
  
   {
     Color a = Color::MakeRGBA8(255, 255, 255, 255);
     Color b = Color::White();
     ASSERT_COLOR_NEAR(a, b);
   }
  
   {
     Color a = Color::MakeRGBA8(63, 127, 191, 127);
     Color b(0.247059, 0.498039, 0.74902, 0.498039);
     ASSERT_COLOR_NEAR(a, b);
   }
 }

References ASSERT_COLOR_NEAR, impeller::saturated::b, impeller::Color::BlackTransparent(), impeller::Color::MakeRGBA8(), and impeller::Color::White().

◆ TEST() [171/523]

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

Definition at line 1378 of file geometry_unittests.cc.

                                      {
   {
     Color a(1.0, 0.5, 0.2, 0.5);
     Color premultiplied = a.Premultiply();
     Color expected = Color(0.5, 0.25, 0.1, 0.5);
     ASSERT_COLOR_NEAR(premultiplied, expected);
   }
  
   {
     Color a(0.5, 0.25, 0.1, 0.5);
     Color unpremultiplied = a.Unpremultiply();
     Color expected = Color(1.0, 0.5, 0.2, 0.5);
     ASSERT_COLOR_NEAR(unpremultiplied, expected);
   }
  
   {
     Color a(0.5, 0.25, 0.1, 0.0);
     Color unpremultiplied = a.Unpremultiply();
     Color expected = Color(0.0, 0.0, 0.0, 0.0);
     ASSERT_COLOR_NEAR(unpremultiplied, expected);
   }
 }

References ASSERT_COLOR_NEAR, impeller::Color::Premultiply(), and impeller::Color::Unpremultiply().

◆ TEST() [172/523]

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

Definition at line 1801 of file geometry_unittests.cc.

                                   {
   {
     std::stringstream stream;
     Color m;
     stream << m;
     ASSERT_EQ(stream.str(), "(0, 0, 0, 0)");
   }
  
   {
     std::stringstream stream;
     Color m(1, 2, 3, 4);
     stream << m;
     ASSERT_EQ(stream.str(), "(1, 2, 3, 4)");
   }
 }

◆ TEST() [173/523]

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

Definition at line 1401 of file geometry_unittests.cc.

                                   {
   {
     Color a(1.0, 0.5, 0.2, 0.5);
     std::array<uint8_t, 4> expected = {255, 128, 51, 128};
     ASSERT_ARRAY_4_NEAR(a.ToR8G8B8A8(), expected);
   }
  
   {
     Color a(0.0, 0.0, 0.0, 0.0);
     std::array<uint8_t, 4> expected = {0, 0, 0, 0};
     ASSERT_ARRAY_4_NEAR(a.ToR8G8B8A8(), expected);
   }
  
   {
     Color a(1.0, 1.0, 1.0, 1.0);
     std::array<uint8_t, 4> expected = {255, 255, 255, 255};
     ASSERT_ARRAY_4_NEAR(a.ToR8G8B8A8(), expected);
   }
 }

References ASSERT_ARRAY_4_NEAR, and impeller::Color::ToR8G8B8A8().

◆ TEST() [174/523]

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

Definition at line 1529 of file geometry_unittests.cc.

                                       {
   {
     auto result = Color::White().SRGBToLinear();
     auto expected = Color(1, 1, 1, 1);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     auto result = Color::BlackTransparent().SRGBToLinear();
     auto expected = Color(0, 0, 0, 0);
     ASSERT_COLOR_NEAR(result, expected);
   }
  
   {
     auto result = Color(0.2, 0.4, 0.6, 0.8).SRGBToLinear();
     auto expected = Color(0.0331048, 0.132868, 0.318547, 0.8);
     ASSERT_COLOR_NEAR(result, expected);
   }
 }

References ASSERT_COLOR_NEAR, impeller::Color::BlackTransparent(), impeller::Color::SRGBToLinear(), and impeller::Color::White().

◆ TEST() [175/523]

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() [176/523]

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

Definition at line 1823 of file geometry_unittests.cc.

                              {
   {
     // Simple 2 color gradient produces color buffer containing exactly those
     // values.
     std::vector<Color> colors = {Color::Red(), Color::Blue()};
     std::vector<Scalar> stops = {0.0, 1.0};
  
     auto gradient = CreateGradientBuffer(colors, stops);
  
     ASSERT_COLOR_BUFFER_NEAR(gradient.color_bytes, colors);
     ASSERT_EQ(gradient.texture_size, 2u);
   }
  
   {
     // Gradient with duplicate stops does not create an empty texture.
     std::vector<Color> colors = {Color::Red(), Color::Yellow(), Color::Black(),
                                  Color::Blue()};
     std::vector<Scalar> stops = {0.0, 0.25, 0.25, 1.0};
  
     auto gradient = CreateGradientBuffer(colors, stops);
     ASSERT_EQ(gradient.texture_size, 5u);
   }
  
   {
     // Simple N color gradient produces color buffer containing exactly those
     // values.
     std::vector<Color> colors = {Color::Red(), Color::Blue(), Color::Green(),
                                  Color::White()};
     std::vector<Scalar> stops = {0.0, 0.33, 0.66, 1.0};
  
     auto gradient = CreateGradientBuffer(colors, stops);
  
     ASSERT_COLOR_BUFFER_NEAR(gradient.color_bytes, colors);
     ASSERT_EQ(gradient.texture_size, 4u);
   }
  
   {
     // Gradient with color stops will lerp and scale buffer.
     std::vector<Color> colors = {Color::Red(), Color::Blue(), Color::Green()};
     std::vector<Scalar> stops = {0.0, 0.25, 1.0};
  
     auto gradient = CreateGradientBuffer(colors, stops);
  
     std::vector<Color> lerped_colors = {
         Color::Red(),
         Color::Blue(),
         Color::Lerp(Color::Blue(), Color::Green(), 0.3333),
         Color::Lerp(Color::Blue(), Color::Green(), 0.6666),
         Color::Green(),
     };
     ASSERT_COLOR_BUFFER_NEAR(gradient.color_bytes, lerped_colors);
     ASSERT_EQ(gradient.texture_size, 5u);
   }
  
   {
     // Gradient size is capped at 1024.
     std::vector<Color> colors = {};
     std::vector<Scalar> stops = {};
     for (auto i = 0u; i < 1025; i++) {
       colors.push_back(Color::Blue());
       stops.push_back(i / 1025.0);
     }
  
     auto gradient = CreateGradientBuffer(colors, stops);
  
     ASSERT_EQ(gradient.texture_size, 1024u);
     ASSERT_EQ(gradient.color_bytes.size(), 1024u * 4);
   }
 }

References ASSERT_COLOR_BUFFER_NEAR, impeller::Color::Black(), impeller::Color::Blue(), impeller::CreateGradientBuffer(), impeller::Color::Green(), impeller::Color::Lerp(), impeller::Color::Red(), impeller::Color::White(), and impeller::Color::Yellow().

◆ TEST() [177/523]

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

Definition at line 1893 of file geometry_unittests.cc.

                                     {
 #if defined(FML_OS_MACOSX) || defined(FML_OS_IOS) || \
     defined(FML_OS_IOS_SIMULATOR)
   ASSERT_EQ(ScalarToHalf(0.0), 0.0f16);
   ASSERT_EQ(ScalarToHalf(0.05), 0.05f16);
   ASSERT_EQ(ScalarToHalf(2.43), 2.43f16);
   ASSERT_EQ(ScalarToHalf(-1.45), -1.45f16);
  
   // 65504 is the largest possible half.
   ASSERT_EQ(ScalarToHalf(65504.0f), 65504.0f16);
   ASSERT_EQ(ScalarToHalf(65504.0f + 1), 65504.0f16);
  
   // Colors
   ASSERT_EQ(HalfVector4(Color::Red()),
             HalfVector4(1.0f16, 0.0f16, 0.0f16, 1.0f16));
   ASSERT_EQ(HalfVector4(Color::Green()),
             HalfVector4(0.0f16, 1.0f16, 0.0f16, 1.0f16));
   ASSERT_EQ(HalfVector4(Color::Blue()),
             HalfVector4(0.0f16, 0.0f16, 1.0f16, 1.0f16));
   ASSERT_EQ(HalfVector4(Color::Black().WithAlpha(0)),
             HalfVector4(0.0f16, 0.0f16, 0.0f16, 0.0f16));
  
   ASSERT_EQ(HalfVector3(Vector3(4.0, 6.0, -1.0)),
             HalfVector3(4.0f16, 6.0f16, -1.0f16));
   ASSERT_EQ(HalfVector2(Vector2(4.0, 6.0)), HalfVector2(4.0f16, 6.0f16));
  
   ASSERT_EQ(Half(0.5f), Half(0.5f16));
   ASSERT_EQ(Half(0.5), Half(0.5f16));
   ASSERT_EQ(Half(5), Half(5.0f16));
 #else
   GTEST_SKIP() << "Half-precision floats (IEEE 754) are not portable and "
                   "only used on Apple platforms.";
 #endif  // FML_OS_MACOSX || FML_OS_IOS || FML_OS_IOS_SIMULATOR
 }

References impeller::Color::Black(), impeller::Color::Blue(), impeller::Color::Green(), impeller::Color::Red(), and impeller::ScalarToHalf().

◆ TEST() [178/523]

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

Definition at line 126 of file geometry_unittests.cc.

                                  {
   auto inverted = Matrix{10,  -9,  -12, 8,   //
                          7,   -12, 11,  22,  //
                          -10, 10,  3,   6,   //
                          -2,  22,  2,   1}
                       .Invert();
  
   auto result = Matrix{
       438.0 / 85123.0,   1751.0 / 85123.0, -7783.0 / 85123.0, 4672.0 / 85123.0,
       393.0 / 85123.0,   -178.0 / 85123.0, -570.0 / 85123.0,  4192 / 85123.0,
       -5230.0 / 85123.0, 2802.0 / 85123.0, -3461.0 / 85123.0, 962.0 / 85123.0,
       2690.0 / 85123.0,  1814.0 / 85123.0, 3896.0 / 85123.0,  319.0 / 85123.0};
  
   ASSERT_MATRIX_NEAR(inverted, result);
 }

References ASSERT_MATRIX_NEAR, and impeller::Matrix::Invert().

◆ TEST() [179/523]

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

Definition at line 79 of file geometry_unittests.cc.

                                      {
   {
     auto rotation = Matrix::MakeRotationZ(Radians{kPiOver4});
     auto invert = rotation.Invert();
     // clang-format off
     auto expect = Matrix{k1OverSqrt2, -k1OverSqrt2, 0, 0,
                          k1OverSqrt2, k1OverSqrt2,  0, 0,
                          0,           0,            1, 0,
                          0,           0,            0, 1};
     // clang-format on
     ASSERT_MATRIX_NEAR(invert, expect);
   }
   {
     auto scale = Matrix::MakeScale(Vector2{2, 4});
     auto invert = scale.Invert();
     auto expect = Matrix{0.5, 0,    0, 0,  //
                          0,   0.25, 0, 0,  //
                          0,   0,    1, 0,  //
                          0,   0,    0, 1};
     ASSERT_MATRIX_NEAR(invert, expect);
   }
 }

References ASSERT_MATRIX_NEAR, impeller::Matrix::Invert(), impeller::k1OverSqrt2, impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeScale().

◆ TEST() [180/523]

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

Definition at line 40 of file geometry_unittests.cc.

                                {
   auto matrix = Matrix::MakeColumn(1, 2, 3, 4,     //
                                    5, 6, 7, 8,     //
                                    9, 10, 11, 12,  //
                                    13, 14, 15, 16);
  
   auto expect = Matrix{1,  2,  3,  4,   //
                        5,  6,  7,  8,   //
                        9,  10, 11, 12,  //
                        13, 14, 15, 16};
  
   ASSERT_TRUE(matrix == expect);
 }

References impeller::Matrix::MakeColumn().

◆ TEST() [181/523]

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

Definition at line 54 of file geometry_unittests.cc.

                             {
   auto matrix = Matrix::MakeRow(1, 2, 3, 4,     //
                                 5, 6, 7, 8,     //
                                 9, 10, 11, 12,  //
                                 13, 14, 15, 16);
  
   auto expect = Matrix{1, 5, 9,  13,  //
                        2, 6, 10, 14,  //
                        3, 7, 11, 15,  //
                        4, 8, 12, 16};
  
   ASSERT_TRUE(matrix == expect);
 }

References impeller::Matrix::MakeRow().

◆ TEST() [182/523]

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

Definition at line 102 of file geometry_unittests.cc.

                                 {
   auto matrix = Matrix{1,  2,  3,  4,   //
                        5,  6,  7,  8,   //
                        9,  10, 11, 12,  //
                        13, 14, 15, 16};
   auto basis = matrix.Basis();
   auto expect = Matrix{1, 2,  3,  0,  //
                        5, 6,  7,  0,  //
                        9, 10, 11, 0,  //
                        0, 0,  0,  1};
   ASSERT_MATRIX_NEAR(basis, expect);
 }

References ASSERT_MATRIX_NEAR, and impeller::Matrix::Basis().

◆ TEST() [183/523]

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

Definition at line 408 of file geometry_unittests.cc.

                                           {
   {
     auto m = Matrix();
     Vector3 x = m.GetBasisX();
     Vector3 y = m.GetBasisY();
     Vector3 z = m.GetBasisZ();
     ASSERT_VECTOR3_NEAR(x, Vector3(1, 0, 0));
     ASSERT_VECTOR3_NEAR(y, Vector3(0, 1, 0));
     ASSERT_VECTOR3_NEAR(z, Vector3(0, 0, 1));
   }
  
   {
     auto m = Matrix::MakeRotationZ(Radians{kPiOver2}) *
              Matrix::MakeRotationX(Radians{kPiOver2}) *
              Matrix::MakeScale(Vector3(2, 3, 4));
     Vector3 x = m.GetBasisX();
     Vector3 y = m.GetBasisY();
     Vector3 z = m.GetBasisZ();
     ASSERT_VECTOR3_NEAR(x, Vector3(0, 2, 0));
     ASSERT_VECTOR3_NEAR(y, Vector3(0, 0, 3));
     ASSERT_VECTOR3_NEAR(z, Vector3(4, 0, 0));
   }
 }

References ASSERT_VECTOR3_NEAR, impeller::kPiOver2, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and x.

◆ TEST() [184/523]

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

Definition at line 432 of file geometry_unittests.cc.

                                             {
   {
     auto m = Matrix();
     Scalar result = m.GetDirectionScale(Vector3{1, 0, 0});
     ASSERT_FLOAT_EQ(result, 1);
   }
  
   {
     auto m = Matrix::MakeRotationX(Degrees{10}) *
              Matrix::MakeRotationY(Degrees{83}) *
              Matrix::MakeRotationZ(Degrees{172});
     Scalar result = m.GetDirectionScale(Vector3{0, 1, 0});
     ASSERT_FLOAT_EQ(result, 1);
   }
  
   {
     auto m = Matrix::MakeRotationZ(Radians{kPiOver2}) *
              Matrix::MakeScale(Vector3(3, 4, 5));
     Scalar result = m.GetDirectionScale(Vector3{2, 0, 0});
     ASSERT_FLOAT_EQ(result, 8);
   }
 }

References impeller::Matrix::GetDirectionScale(), impeller::kPiOver2, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeScale().

◆ TEST() [185/523]

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

Definition at line 333 of file geometry_unittests.cc.

                                               {
   {
     auto m = Matrix::MakeScale({3, 1, 1});
     ASSERT_EQ(m.GetMaxBasisLengthXY(), 3);
  
     m = m * Matrix::MakeSkew(0, 4);
     ASSERT_EQ(m.GetMaxBasisLengthXY(), 5);
   }
  
   {
     auto m = Matrix::MakeScale({-3, 4, 7});
     ASSERT_EQ(m.GetMaxBasisLengthXY(), 4);
   }
  
   {
     // clang-format off
     auto m = Matrix::MakeColumn(
         1.0f, 0.0f, 0.0f, 0.0f,
         0.0f, 1.0f, 0.0f, 0.0f,
         4.0f, 0.0f, 1.0f, 0.0f,
         0.0f, 0.0f, 0.0f, 1.0f
     );
     // clang-format on
     ASSERT_EQ(m.GetMaxBasisLengthXY(), 1.0f);
   }
 }

References impeller::Matrix::MakeColumn(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeSkew().

◆ TEST() [186/523]

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

Definition at line 481 of file geometry_unittests.cc.

                                  {
   {
     auto m = Matrix::MakeLookAt(Vector3(0, 0, -1), Vector3(0, 0, 1),
                                 Vector3(0, 1, 0));
     auto expected = Matrix{
         1, 0, 0, 0,  //
         0, 1, 0, 0,  //
         0, 0, 1, 0,  //
         0, 0, 1, 1,  //
     };
     ASSERT_MATRIX_NEAR(m, expected);
   }
  
   // Sideways tilt.
   {
     auto m = Matrix::MakeLookAt(Vector3(0, 0, -1), Vector3(0, 0, 1),
                                 Vector3(1, 1, 0).Normalize());
  
     // clang-format off
     auto expected = Matrix{
         k1OverSqrt2, k1OverSqrt2, 0, 0,
        -k1OverSqrt2, k1OverSqrt2, 0, 0,
         0,           0,           1, 0,
         0,           0,           1, 1,
     };
     // clang-format on
     ASSERT_MATRIX_NEAR(m, expected);
   }
  
   // Half way between +x and -y, yaw 90
   {
     auto m =
         Matrix::MakeLookAt(Vector3(), Vector3(10, -10, 0), Vector3(0, 0, -1));
  
     // clang-format off
     auto expected = Matrix{
        -k1OverSqrt2,  0,  k1OverSqrt2, 0,
        -k1OverSqrt2,  0, -k1OverSqrt2, 0,
         0,           -1,  0,           0,
         0,            0,  0,           1,
     };
     // clang-format on
     ASSERT_MATRIX_NEAR(m, expected);
   }
 }

References ASSERT_MATRIX_NEAR, impeller::k1OverSqrt2, and impeller::Matrix::MakeLookAt().

◆ TEST() [187/523]

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

Definition at line 360 of file geometry_unittests.cc.

                                            {
   {
     auto m = Matrix::MakeOrthographic(Size(100, 200));
     auto expect = Matrix{
         0.02, 0,     0,   0,  //
         0,    -0.01, 0,   0,  //
         0,    0,     0,   0,  //
         -1,   1,     0.5, 1,  //
     };
     ASSERT_MATRIX_NEAR(m, expect);
   }
  
   {
     auto m = Matrix::MakeOrthographic(Size(400, 100));
     auto expect = Matrix{
         0.005, 0,     0,   0,  //
         0,     -0.02, 0,   0,  //
         0,     0,     0,   0,  //
         -1,    1,     0.5, 1,  //
     };
     ASSERT_MATRIX_NEAR(m, expect);
   }
 }

References ASSERT_MATRIX_NEAR, and impeller::Matrix::MakeOrthographic().

◆ TEST() [188/523]

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

Definition at line 384 of file geometry_unittests.cc.

                                           {
   {
     auto m = Matrix::MakePerspective(Degrees(60), Size(100, 200), 1, 10);
     auto expect = Matrix{
         3.4641, 0,       0,        0,  //
         0,      1.73205, 0,        0,  //
         0,      0,       1.11111,  1,  //
         0,      0,       -1.11111, 0,  //
     };
     ASSERT_MATRIX_NEAR(m, expect);
   }
  
   {
     auto m = Matrix::MakePerspective(Radians(1), 2, 10, 20);
     auto expect = Matrix{
         0.915244, 0,       0,   0,  //
         0,        1.83049, 0,   0,  //
         0,        0,       2,   1,  //
         0,        0,       -20, 0,  //
     };
     ASSERT_MATRIX_NEAR(m, expect);
   }
 }

References ASSERT_MATRIX_NEAR, and impeller::Matrix::MakePerspective().

◆ TEST() [189/523]

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

Definition at line 278 of file geometry_unittests.cc.

                                                      {
   {
     auto matrix = Matrix::MakeRotation(Quaternion({1, 0, 0}, kPiOver2));
     auto expected = Matrix::MakeRotationX(Radians(kPiOver2));
     ASSERT_MATRIX_NEAR(matrix, expected);
   }
  
   {
     auto matrix = Matrix::MakeRotation(Quaternion({0, 1, 0}, kPiOver2));
     auto expected = Matrix::MakeRotationY(Radians(kPiOver2));
     ASSERT_MATRIX_NEAR(matrix, expected);
   }
  
   {
     auto matrix = Matrix::MakeRotation(Quaternion({0, 0, 1}, kPiOver2));
     auto expected = Matrix::MakeRotationZ(Radians(kPiOver2));
     ASSERT_MATRIX_NEAR(matrix, expected);
   }
 }

References ASSERT_MATRIX_NEAR, impeller::kPiOver2, impeller::Matrix::MakeRotation(), impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), and impeller::Matrix::MakeRotationZ().

◆ TEST() [190/523]

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

Definition at line 1726 of file geometry_unittests.cc.

                                    {
   {
     std::stringstream stream;
     Matrix m;
     stream << m;
     ASSERT_EQ(stream.str(), R"((
        1.000000,       0.000000,       0.000000,       0.000000,
        0.000000,       1.000000,       0.000000,       0.000000,
        0.000000,       0.000000,       1.000000,       0.000000,
        0.000000,       0.000000,       0.000000,       1.000000,
 ))");
   }
  
   {
     std::stringstream stream;
     Matrix m = Matrix::MakeTranslation(Vector3(10, 20, 30));
     stream << m;
  
     ASSERT_EQ(stream.str(), R"((
        1.000000,       0.000000,       0.000000,      10.000000,
        0.000000,       1.000000,       0.000000,      20.000000,
        0.000000,       0.000000,       1.000000,      30.000000,
        0.000000,       0.000000,       0.000000,       1.000000,
 ))");
   }
 }

References impeller::Matrix::MakeTranslation().

◆ TEST() [191/523]

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

Definition at line 298 of file geometry_unittests.cc.

                                              {
   {
     auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                   Matrix::MakeRotationZ(Radians{kPiOver2}) *
                   Matrix::MakeScale({2.0, 2.0, 2.0});
     auto vector = Vector4(10, 20, 30, 2);
  
     Vector4 result = matrix.TransformDirection(vector);
     auto expected = Vector4(-40, 20, 60, 2);
     ASSERT_VECTOR4_NEAR(result, expected);
   }
  
   {
     auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                   Matrix::MakeRotationZ(Radians{kPiOver2}) *
                   Matrix::MakeScale({2.0, 2.0, 2.0});
     auto vector = Vector3(10, 20, 30);
  
     Vector3 result = matrix.TransformDirection(vector);
     auto expected = Vector3(-40, 20, 60);
     ASSERT_VECTOR3_NEAR(result, expected);
   }
  
   {
     auto matrix = Matrix::MakeTranslation({0, -0.4, 100}) *
                   Matrix::MakeRotationZ(Radians{kPiOver2}) *
                   Matrix::MakeScale({2.0, 2.0, 2.0});
     auto vector = Point(10, 20);
  
     Point result = matrix.TransformDirection(vector);
     auto expected = Point(-40, 20);
     ASSERT_POINT_NEAR(result, expected);
   }
 }

References ASSERT_POINT_NEAR, ASSERT_VECTOR3_NEAR, ASSERT_VECTOR4_NEAR, impeller::kPiOver2, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [192/523]

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

Definition at line 455 of file geometry_unittests.cc.

                                                {
   {
     auto m = Matrix();
     bool result = m.IsTranslationScaleOnly();
     ASSERT_TRUE(result);
   }
  
   {
     auto m = Matrix::MakeScale(Vector3(2, 3, 4));
     bool result = m.IsTranslationScaleOnly();
     ASSERT_TRUE(result);
   }
  
   {
     auto m = Matrix::MakeTranslation(Vector3(2, 3, 4));
     bool result = m.IsTranslationScaleOnly();
     ASSERT_TRUE(result);
   }
  
   {
     auto m = Matrix::MakeRotationZ(Degrees(10));
     bool result = m.IsTranslationScaleOnly();
     ASSERT_FALSE(result);
   }
 }

References impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [193/523]

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

Definition at line 213 of file geometry_unittests.cc.

                                                {
   {
     auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                   Matrix::MakeRotationZ(Radians{kPiOver2}) *
                   Matrix::MakeScale({2.0, 2.0, 2.0});
     auto vector = Vector4(10, 20, 30, 2);
  
     Vector4 result = matrix * vector;
     auto expected = Vector4(160, 220, 260, 2);
     ASSERT_VECTOR4_NEAR(result, expected);
   }
  
   {
     auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                   Matrix::MakeRotationZ(Radians{kPiOver2}) *
                   Matrix::MakeScale({2.0, 2.0, 2.0});
     auto vector = Vector3(10, 20, 30);
  
     Vector3 result = matrix * vector;
     auto expected = Vector3(60, 120, 160);
     ASSERT_VECTOR3_NEAR(result, expected);
   }
  
   {
     auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                   Matrix::MakeRotationZ(Radians{kPiOver2}) *
                   Matrix::MakeScale({2.0, 2.0, 2.0});
     auto vector = Point(10, 20);
  
     Point result = matrix * vector;
     auto expected = Point(60, 120);
     ASSERT_POINT_NEAR(result, expected);
   }
  
   // Matrix Vector ops should respect perspective transforms.
   {
     auto matrix = Matrix::MakePerspective(Radians(kPiOver2), 1, 1, 100);
     auto vector = Vector3(3, 3, -3);
  
     Vector3 result = matrix * vector;
     auto expected = Vector3(-1, -1, 1.3468);
     ASSERT_VECTOR3_NEAR(result, expected);
   }
  
   {
     auto matrix = Matrix::MakePerspective(Radians(kPiOver2), 1, 1, 100) *
                   Matrix::MakeTranslation(Vector3(0, 0, -3));
     auto point = Point(3, 3);
  
     Point result = matrix * point;
     auto expected = Point(-1, -1);
     ASSERT_POINT_NEAR(result, expected);
   }
  
   // Resolves to 0 on perspective singularity.
   {
     auto matrix = Matrix::MakePerspective(Radians(kPiOver2), 1, 1, 100);
     auto point = Point(3, 3);
  
     Point result = matrix * point;
     auto expected = Point(0, 0);
     ASSERT_POINT_NEAR(result, expected);
   }
 }

References ASSERT_POINT_NEAR, ASSERT_VECTOR3_NEAR, ASSERT_VECTOR4_NEAR, impeller::kPiOver2, impeller::Matrix::MakePerspective(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [194/523]

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

Definition at line 115 of file geometry_unittests.cc.

                                          {
   auto rotation = Matrix::MakeRotationZ(Radians{kPiOver4});
   auto invert = rotation.Invert();
   ASSERT_MATRIX_NEAR(rotation * invert, Matrix{});
 }

References ASSERT_MATRIX_NEAR, impeller::Matrix::Invert(), impeller::kPiOver4, and impeller::Matrix::MakeRotationZ().

◆ TEST() [195/523]

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

Definition at line 938 of file geometry_unittests.cc.

                              {
   Point a(-1, -2);
   auto a_abs = a.Abs();
   auto expected = Point(1, 2);
   ASSERT_POINT_NEAR(a_abs, expected);
 }

References impeller::TPoint< T >::Abs(), and ASSERT_POINT_NEAR.

◆ TEST() [196/523]

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

Definition at line 975 of file geometry_unittests.cc.

                                  {
   // Negative result in the CCW (with up = -Y) direction.
   {
     Point a(1, 1);
     Point b(1, -1);
     Radians actual = a.AngleTo(b);
     Radians expected = Radians{-kPi / 2};
     ASSERT_FLOAT_EQ(actual.radians, expected.radians);
   }
  
   // Check the other direction to ensure the result is signed correctly.
   {
     Point a(1, -1);
     Point b(1, 1);
     Radians actual = a.AngleTo(b);
     Radians expected = Radians{kPi / 2};
     ASSERT_FLOAT_EQ(actual.radians, expected.radians);
   }
  
   // Differences in magnitude should have no impact on the result.
   {
     Point a(100, -100);
     Point b(0.01, 0.01);
     Radians actual = a.AngleTo(b);
     Radians expected = Radians{kPi / 2};
     ASSERT_FLOAT_EQ(actual.radians, expected.radians);
   }
 }

References impeller::TPoint< T >::AngleTo(), impeller::saturated::b, impeller::kPi, and impeller::Radians::radians.

◆ TEST() [197/523]

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

Definition at line 1113 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, and impeller::TPoint< T >::Ceil().

◆ TEST() [198/523]

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

Definition at line 893 of file geometry_unittests.cc.

                                       {
   {
     Point p(1, 0);
     Scalar s = p.Cross(Point(-1, 0));
     ASSERT_FLOAT_EQ(s, 0);
   }
  
   {
     Point p(0, -1);
     Scalar s = p.Cross(Point(-1, 0));
     ASSERT_FLOAT_EQ(s, -1);
   }
  
   {
     Point p(1, 2);
     Scalar s = p.Cross(Point(3, -4));
     ASSERT_FLOAT_EQ(s, -10);
   }
 }

References impeller::TPoint< T >::Cross().

◆ TEST() [199/523]

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

Definition at line 873 of file geometry_unittests.cc.

                                     {
   {
     Point p(1, 0);
     Scalar s = p.Dot(Point(-1, 0));
     ASSERT_FLOAT_EQ(s, -1);
   }
  
   {
     Point p(0, -1);
     Scalar s = p.Dot(Point(-1, 0));
     ASSERT_FLOAT_EQ(s, 0);
   }
  
   {
     Point p(1, 2);
     Scalar s = p.Dot(Point(3, -4));
     ASSERT_FLOAT_EQ(s, -5);
   }
 }

References impeller::TPoint< T >::Dot().

◆ TEST() [200/523]

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

Definition at line 1092 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, and impeller::TPoint< T >::Floor().

◆ TEST() [201/523]

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

Definition at line 678 of file geometry_unittests.cc.

                                                {
   // Integer on LHS, float on RHS
   {
     IPoint p1(1, 2);
     Point p2 = p1 + Point(1, 2);
     ASSERT_FLOAT_EQ(p2.x, 2u);
     ASSERT_FLOAT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(3, 6);
     Point p2 = p1 - Point(1, 2);
     ASSERT_FLOAT_EQ(p2.x, 2u);
     ASSERT_FLOAT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(1, 2);
     Point p2 = p1 * Point(2, 3);
     ASSERT_FLOAT_EQ(p2.x, 2u);
     ASSERT_FLOAT_EQ(p2.y, 6u);
   }
  
   {
     IPoint p1(2, 6);
     Point p2 = p1 / Point(2, 3);
     ASSERT_FLOAT_EQ(p2.x, 1u);
     ASSERT_FLOAT_EQ(p2.y, 2u);
   }
  
   // Float on LHS, integer on RHS
   {
     Point p1(1, 2);
     Point p2 = p1 + IPoint(1, 2);
     ASSERT_FLOAT_EQ(p2.x, 2u);
     ASSERT_FLOAT_EQ(p2.y, 4u);
   }
  
   {
     Point p1(3, 6);
     Point p2 = p1 - IPoint(1, 2);
     ASSERT_FLOAT_EQ(p2.x, 2u);
     ASSERT_FLOAT_EQ(p2.y, 4u);
   }
  
   {
     Point p1(1, 2);
     Point p2 = p1 * IPoint(2, 3);
     ASSERT_FLOAT_EQ(p2.x, 2u);
     ASSERT_FLOAT_EQ(p2.y, 6u);
   }
  
   {
     Point p1(2, 6);
     Point p2 = p1 / IPoint(2, 3);
     ASSERT_FLOAT_EQ(p2.x, 1u);
     ASSERT_FLOAT_EQ(p2.y, 2u);
   }
 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [202/523]

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

Definition at line 1155 of file geometry_unittests.cc.

                               {
   Point p(1, 2);
   Point result = p.Lerp({5, 10}, 0.75);
   Point expected(4, 8);
   ASSERT_POINT_NEAR(result, expected);
 }

References ASSERT_POINT_NEAR, and impeller::TPoint< T >::Lerp().

◆ TEST() [203/523]

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

Definition at line 1071 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, and impeller::TPoint< T >::Max().

◆ TEST() [204/523]

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

Definition at line 1004 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, and impeller::TPoint< T >::Min().

◆ TEST() [205/523]

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

Definition at line 1753 of file geometry_unittests.cc.

                                   {
   {
     std::stringstream stream;
     Point m;
     stream << m;
     ASSERT_EQ(stream.str(), "(0, 0)");
   }
  
   {
     std::stringstream stream;
     Point m(13, 37);
     stream << m;
     ASSERT_EQ(stream.str(), "(13, 37)");
   }
 }

◆ TEST() [206/523]

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

Definition at line 913 of file geometry_unittests.cc.

                                  {
   {
     Point axis = Point(0, 1);
     Point a(2, 3);
     auto reflected = a.Reflect(axis);
     auto expected = Point(2, -3);
     ASSERT_POINT_NEAR(reflected, expected);
   }
  
   {
     Point axis = Point(1, 1).Normalize();
     Point a(1, 0);
     auto reflected = a.Reflect(axis);
     auto expected = Point(0, -1);
     ASSERT_POINT_NEAR(reflected, expected);
   }
  
   {
     Point axis = Point(1, 1).Normalize();
     Point a(-1, -1);
     auto reflected = a.Reflect(axis);
     ASSERT_POINT_NEAR(reflected, -a);
   }
 }

References ASSERT_POINT_NEAR, impeller::TPoint< T >::Normalize(), and impeller::TPoint< T >::Reflect().

◆ TEST() [207/523]

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

Definition at line 945 of file geometry_unittests.cc.

                                 {
   {
     Point a(1, 0);
     auto rotated = a.Rotate(Radians{kPiOver2});
     auto expected = Point(0, 1);
     ASSERT_POINT_NEAR(rotated, expected);
   }
  
   {
     Point a(1, 0);
     auto rotated = a.Rotate(Radians{-kPiOver2});
     auto expected = Point(0, -1);
     ASSERT_POINT_NEAR(rotated, expected);
   }
  
   {
     Point a(1, 0);
     auto rotated = a.Rotate(Radians{kPi});
     auto expected = Point(-1, 0);
     ASSERT_POINT_NEAR(rotated, expected);
   }
  
   {
     Point a(1, 0);
     auto rotated = a.Rotate(Radians{kPi * 1.5});
     auto expected = Point(0, -1);
     ASSERT_POINT_NEAR(rotated, expected);
   }
 }

References ASSERT_POINT_NEAR, impeller::kPi, impeller::kPiOver2, and impeller::TPoint< T >::Rotate().

◆ TEST() [208/523]

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

Definition at line 1134 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, and impeller::TPoint< T >::Round().

◆ TEST() [209/523]

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

Definition at line 527 of file geometry_unittests.cc.

                                    {
   auto q1 = Quaternion{{0.0, 0.0, 1.0}, 0.0};
   auto q2 = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
  
   auto q3 = q1.Slerp(q2, 0.5);
  
   auto expected = Quaternion{{0.0, 0.0, 1.0}, kPiOver4 / 2.0};
  
   ASSERT_QUATERNION_NEAR(q3, expected);
 }

References ASSERT_QUATERNION_NEAR, and impeller::kPiOver4.

◆ TEST() [210/523]

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

Definition at line 538 of file geometry_unittests.cc.

                                              {
   {
     Quaternion q({0, 0, 1}, 0);
     Vector3 v(0, 1, 0);
  
     Vector3 result = q * v;
     Vector3 expected(0, 1, 0);
  
     ASSERT_VECTOR3_NEAR(result, expected);
   }
  
   {
     Quaternion q({0, 0, 1}, k2Pi);
     Vector3 v(1, 0, 0);
  
     Vector3 result = q * v;
     Vector3 expected(1, 0, 0);
  
     ASSERT_VECTOR3_NEAR(result, expected);
   }
  
   {
     Quaternion q({0, 0, 1}, kPiOver4);
     Vector3 v(0, 1, 0);
  
     Vector3 result = q * v;
     Vector3 expected(-k1OverSqrt2, k1OverSqrt2, 0);
  
     ASSERT_VECTOR3_NEAR(result, expected);
   }
  
   {
     Quaternion q(Vector3(1, 0, 1).Normalize(), kPi);
     Vector3 v(0, 0, -1);
  
     Vector3 result = q * v;
     Vector3 expected(-1, 0, 0);
  
     ASSERT_VECTOR3_NEAR(result, expected);
   }
 }

References ASSERT_VECTOR3_NEAR, impeller::k1OverSqrt2, impeller::k2Pi, impeller::kPi, and impeller::kPiOver4.

◆ TEST() [211/523]

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

Definition at line 68 of file geometry_unittests.cc.

                                    {
   auto rotation = Matrix::MakeRotationZ(Radians{kPiOver4});
   // clang-format off
   auto expect = Matrix{k1OverSqrt2,  k1OverSqrt2, 0, 0,
                        -k1OverSqrt2, k1OverSqrt2, 0, 0,
                        0,            0,           1, 0,
                        0,            0,           0, 1};
   // clang-format on
   ASSERT_MATRIX_NEAR(rotation, expect);
 }

References ASSERT_MATRIX_NEAR, impeller::k1OverSqrt2, impeller::kPiOver4, and impeller::Matrix::MakeRotationZ().

◆ TEST() [212/523]

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

Definition at line 31 of file geometry_unittests.cc.

                                       {
   ASSERT_FALSE(ScalarNearlyEqual(0.0021f, 0.001f));
   ASSERT_TRUE(ScalarNearlyEqual(0.0019f, 0.001f));
   ASSERT_TRUE(ScalarNearlyEqual(0.002f, 0.001f, 0.0011f));
   ASSERT_FALSE(ScalarNearlyEqual(0.002f, 0.001f, 0.0009f));
   ASSERT_TRUE(ScalarNearlyEqual(
       1.0f, 1.0f + std::numeric_limits<float>::epsilon() * 4));
 }

References impeller::ScalarNearlyEqual().

◆ TEST() [213/523]

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

Definition at line 1210 of file geometry_unittests.cc.

                                             {
   {
     SeparatedVector2 v(Vector2(10, 0));
     Radians actual = v.AngleTo(SeparatedVector2(Vector2(5, 0)));
     Radians expected = Radians{0};
     ASSERT_NEAR(actual.radians, expected.radians, kEhCloseEnough);
   }
  
   {
     SeparatedVector2 v(Vector2(10, 0));
     Radians actual = v.AngleTo(SeparatedVector2(Vector2(0, -5)));
     Radians expected = Radians{-kPi / 2};
     ASSERT_NEAR(actual.radians, expected.radians, kEhCloseEnough);
   }
 }

References impeller::SeparatedVector2::AngleTo(), impeller::kEhCloseEnough, impeller::kPi, and impeller::Radians::radians.

◆ TEST() [214/523]

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

Definition at line 1187 of file geometry_unittests.cc.

                                                  {
   // Parallel
   {
     SeparatedVector2 v(Vector2(10, 0));
     Scalar actual = v.GetAlignment(SeparatedVector2(Vector2(5, 0)));
     ASSERT_NEAR(actual, 1, kEhCloseEnough);
   }
  
   // Perpendicular
   {
     SeparatedVector2 v(Vector2(10, 0));
     Scalar actual = v.GetAlignment(SeparatedVector2(Vector2(0, 5)));
     ASSERT_NEAR(actual, 0, kEhCloseEnough);
   }
  
   // Opposite parallel
   {
     SeparatedVector2 v(Vector2(0, 10));
     Scalar actual = v.GetAlignment(SeparatedVector2(Vector2(0, -5)));
     ASSERT_NEAR(actual, -1, kEhCloseEnough);
   }
 }

References impeller::SeparatedVector2::GetAlignment(), and impeller::kEhCloseEnough.

◆ TEST() [215/523]

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

Definition at line 1182 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, and impeller::SeparatedVector2::GetVector().

◆ TEST() [216/523]

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

Definition at line 1176 of file geometry_unittests.cc.

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

References ASSERT_POINT_NEAR, impeller::SeparatedVector2::direction, impeller::kEhCloseEnough, and impeller::SeparatedVector2::magnitude.

◆ TEST() [217/523]

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

Definition at line 738 of file geometry_unittests.cc.

                                        {
   // Point on LHS, Size on RHS
   {
     IPoint p1(1, 2);
     IPoint p2 = p1 + ISize(1, 2);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(3, 6);
     IPoint p2 = p1 - ISize(1, 2);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     IPoint p1(1, 2);
     IPoint p2 = p1 * ISize(2, 3);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 6u);
   }
  
   {
     IPoint p1(2, 6);
     IPoint p2 = p1 / ISize(2, 3);
     ASSERT_EQ(p2.x, 1u);
     ASSERT_EQ(p2.y, 2u);
   }
  
   // Size on LHS, Point on RHS
   {
     ISize p1(1, 2);
     IPoint p2 = p1 + IPoint(1, 2);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     ISize p1(3, 6);
     IPoint p2 = p1 - IPoint(1, 2);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 4u);
   }
  
   {
     ISize p1(1, 2);
     IPoint p2 = p1 * IPoint(2, 3);
     ASSERT_EQ(p2.x, 2u);
     ASSERT_EQ(p2.y, 6u);
   }
  
   {
     ISize p1(2, 6);
     IPoint p2 = p1 / IPoint(2, 3);
     ASSERT_EQ(p2.x, 1u);
     ASSERT_EQ(p2.y, 2u);
   }
 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [218/523]

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

Definition at line 142 of file geometry_unittests.cc.

                                       {
   auto rotated = Matrix::MakeRotationZ(Radians{kPiOver4});
  
   auto result = rotated.Decompose();
  
   ASSERT_TRUE(result.has_value());
  
   MatrixDecomposition res = result.value();
  
   auto quaternion = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
   ASSERT_QUATERNION_NEAR(res.rotation, quaternion);
 }

References ASSERT_QUATERNION_NEAR, impeller::Matrix::Decompose(), impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), and impeller::MatrixDecomposition::rotation.

◆ TEST() [219/523]

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

Definition at line 155 of file geometry_unittests.cc.

                                        {
   auto rotated = Matrix::MakeRotationZ(Radians{kPiOver4});
   auto scaled = Matrix::MakeScale({2.0, 3.0, 1.0});
   auto translated = Matrix::MakeTranslation({-200, 750, 20});
  
   auto result = (translated * rotated * scaled).Decompose();
  
   ASSERT_TRUE(result.has_value());
  
   MatrixDecomposition res = result.value();
  
   auto quaternion = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
  
   ASSERT_QUATERNION_NEAR(res.rotation, quaternion);
  
   ASSERT_FLOAT_EQ(res.translation.x, -200);
   ASSERT_FLOAT_EQ(res.translation.y, 750);
   ASSERT_FLOAT_EQ(res.translation.z, 20);
  
   ASSERT_FLOAT_EQ(res.scale.x, 2);
   ASSERT_FLOAT_EQ(res.scale.y, 3);
   ASSERT_FLOAT_EQ(res.scale.z, 1);
 }

References ASSERT_QUATERNION_NEAR, impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::MatrixDecomposition::rotation, impeller::MatrixDecomposition::scale, impeller::MatrixDecomposition::translation, impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ TEST() [220/523]

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

Definition at line 179 of file geometry_unittests.cc.

                                       {
   /*
    *  Decomposition.
    */
   auto rotated = Matrix::MakeRotationZ(Radians{kPiOver4});
  
   auto result = rotated.Decompose();
  
   ASSERT_TRUE(result.has_value());
  
   MatrixDecomposition res = result.value();
  
   auto quaternion = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
  
   ASSERT_QUATERNION_NEAR(res.rotation, quaternion);
  
   /*
    *  Recomposition.
    */
   ASSERT_MATRIX_NEAR(rotated, Matrix{res});
 }

References ASSERT_MATRIX_NEAR, ASSERT_QUATERNION_NEAR, impeller::Matrix::Decompose(), impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), and impeller::MatrixDecomposition::rotation.

◆ TEST() [221/523]

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

Definition at line 201 of file geometry_unittests.cc.

                                        {
   auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                 Matrix::MakeRotationZ(Radians{kPiOver4}) *
                 Matrix::MakeScale({2.0, 2.0, 2.0});
  
   auto result = matrix.Decompose();
  
   ASSERT_TRUE(result.has_value());
  
   ASSERT_MATRIX_NEAR(matrix, Matrix{result.value()});
 }

References ASSERT_MATRIX_NEAR, impeller::Matrix::Decompose(), impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [222/523]

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

Definition at line 1817 of file geometry_unittests.cc.

                              {
   ASSERT_EQ(Color::ToIColor(Color(0, 0, 0, 0)), 0u);
   ASSERT_EQ(Color::ToIColor(Color(1.0, 1.0, 1.0, 1.0)), 0xFFFFFFFF);
   ASSERT_EQ(Color::ToIColor(Color(0.5, 0.5, 1.0, 1.0)), 0xFF8080FF);
 }

References impeller::Color::ToIColor().

◆ TEST() [223/523]

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

Definition at line 1120 of file geometry_unittests.cc.

                                 {
   Vector3 p(1.5, 2.3, 3.9);
   Vector3 result = p.Ceil();
   Vector3 expected(2, 3, 4);
   ASSERT_VECTOR3_NEAR(result, expected);
 }

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Ceil().

◆ TEST() [224/523]

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

Definition at line 1099 of file geometry_unittests.cc.

                                  {
   Vector3 p(1.5, 2.3, 3.9);
   Vector3 result = p.Floor();
   Vector3 expected(1, 2, 3);
   ASSERT_VECTOR3_NEAR(result, expected);
 }

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Floor().

◆ TEST() [225/523]

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

Definition at line 1162 of file geometry_unittests.cc.

                                 {
   Vector3 p(1, 2, 3);
   Vector3 result = p.Lerp({5, 10, 15}, 0.75);
   Vector3 expected(4, 8, 12);
   ASSERT_VECTOR3_NEAR(result, expected);
 }

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Lerp().

◆ TEST() [226/523]

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

Definition at line 1078 of file geometry_unittests.cc.

                                {
   Vector3 p(1, 2, 3);
   Vector3 result = p.Max({0, 10, 2});
   Vector3 expected(1, 10, 3);
   ASSERT_VECTOR3_NEAR(result, expected);
 }

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Max().

◆ TEST() [227/523]

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

Definition at line 1057 of file geometry_unittests.cc.

                                {
   Vector3 p(1, 2, 3);
   Vector3 result = p.Min({0, 10, 2});
   Vector3 expected(0, 2, 2);
   ASSERT_VECTOR3_NEAR(result, expected);
 }

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Min().

◆ TEST() [228/523]

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

Definition at line 1769 of file geometry_unittests.cc.

                                     {
   {
     std::stringstream stream;
     Vector3 m;
     stream << m;
     ASSERT_EQ(stream.str(), "(0, 0, 0)");
   }
  
   {
     std::stringstream stream;
     Vector3 m(1, 2, 3);
     stream << m;
     ASSERT_EQ(stream.str(), "(1, 2, 3)");
   }
 }

◆ TEST() [229/523]

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

Definition at line 1141 of file geometry_unittests.cc.

                                  {
   Vector3 p(1.5, 2.3, 3.9);
   Vector3 result = p.Round();
   Vector3 expected(2, 2, 4);
   ASSERT_VECTOR3_NEAR(result, expected);
 }

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Round().

◆ TEST() [230/523]

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

Definition at line 1127 of file geometry_unittests.cc.

                                 {
   Vector4 p(1.5, 2.3, 3.9, 4.0);
   Vector4 result = p.Ceil();
   Vector4 expected(2, 3, 4, 4);
   ASSERT_VECTOR4_NEAR(result, expected);
 }

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Ceil().

◆ TEST() [231/523]

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

Definition at line 1106 of file geometry_unittests.cc.

                                  {
   Vector4 p(1.5, 2.3, 3.9, 4.0);
   Vector4 result = p.Floor();
   Vector4 expected(1, 2, 3, 4);
   ASSERT_VECTOR4_NEAR(result, expected);
 }

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Floor().

◆ TEST() [232/523]

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

Definition at line 1011 of file geometry_unittests.cc.

                                     {
   {
     Vector4 v;
     ASSERT_TRUE(v.IsFinite());
     v.x = std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.x = -std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.x = -std::numeric_limits<Scalar>::quiet_NaN();
     ASSERT_FALSE(v.IsFinite());
   }
  
   {
     Vector4 v;
     ASSERT_TRUE(v.IsFinite());
     v.y = std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.y = -std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.y = -std::numeric_limits<Scalar>::quiet_NaN();
     ASSERT_FALSE(v.IsFinite());
   }
  
   {
     Vector4 v;
     ASSERT_TRUE(v.IsFinite());
     v.z = std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.z = -std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.z = -std::numeric_limits<Scalar>::quiet_NaN();
     ASSERT_FALSE(v.IsFinite());
   }
  
   {
     Vector4 v;
     ASSERT_TRUE(v.IsFinite());
     v.w = std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.w = -std::numeric_limits<Scalar>::infinity();
     ASSERT_FALSE(v.IsFinite());
     v.w = -std::numeric_limits<Scalar>::quiet_NaN();
     ASSERT_FALSE(v.IsFinite());
   }
 }

References impeller::Vector4::IsFinite(), impeller::Vector4::w, impeller::Vector4::x, impeller::Vector4::y, and impeller::Vector4::z.

◆ TEST() [233/523]

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

Definition at line 1169 of file geometry_unittests.cc.

                                 {
   Vector4 p(1, 2, 3, 4);
   Vector4 result = p.Lerp({5, 10, 15, 20}, 0.75);
   Vector4 expected(4, 8, 12, 16);
   ASSERT_VECTOR4_NEAR(result, expected);
 }

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Lerp().

◆ TEST() [234/523]

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

Definition at line 1085 of file geometry_unittests.cc.

                                {
   Vector4 p(1, 2, 3, 4);
   Vector4 result = p.Max({0, 10, 2, 1});
   Vector4 expected(1, 10, 3, 4);
   ASSERT_VECTOR4_NEAR(result, expected);
 }

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Max().

◆ TEST() [235/523]

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

Definition at line 1064 of file geometry_unittests.cc.

                                {
   Vector4 p(1, 2, 3, 4);
   Vector4 result = p.Min({0, 10, 2, 1});
   Vector4 expected(0, 2, 2, 1);
   ASSERT_VECTOR4_NEAR(result, expected);
 }

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Min().

◆ TEST() [236/523]

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

Definition at line 1785 of file geometry_unittests.cc.

                                     {
   {
     std::stringstream stream;
     Vector4 m;
     stream << m;
     ASSERT_EQ(stream.str(), "(0, 0, 0, 1)");
   }
  
   {
     std::stringstream stream;
     Vector4 m(1, 2, 3, 4);
     stream << m;
     ASSERT_EQ(stream.str(), "(1, 2, 3, 4)");
   }
 }

◆ TEST() [237/523]

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

Definition at line 1148 of file geometry_unittests.cc.

                                  {
   Vector4 p(1.5, 2.3, 3.9, 4.0);
   Vector4 result = p.Round();
   Vector4 expected(2, 2, 4, 4);
   ASSERT_VECTOR4_NEAR(result, expected);
 }

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Round().

◆ TEST() [238/523]

impeller::testing::TEST	(	LineContents	,
		CalculatePerVertex
	)

Definition at line 59 of file line_contents_unittests.cc.

                                        {
   LineVertexShader::PerVertexData per_vertex[4];
   auto geometry = std::make_unique<LineGeometry>(
       /*p0=*/Point{100, 100},  //
       /*p1=*/Point{200, 100},  //
       StrokeParameters{
           .width = 5.f,
           .cap = Cap::kButt,
       });
   Matrix transform;
  
   fml::StatusOr<LineContents::EffectiveLineParameters> status =
       LineContents::CalculatePerVertex(per_vertex, geometry.get(), transform);
   Scalar offset =
       (LineContents::kSampleRadius * 2.0 + geometry->GetWidth()) / 2.f;
   ASSERT_TRUE(status.ok());
   EXPECT_EQ(status.value().width, 5.f);
   EXPECT_EQ(status.value().radius, LineContents::kSampleRadius);
   EXPECT_POINT_NEAR(per_vertex[0].position,
                     Point(100 - LineContents::kSampleRadius, 100 + offset));
   EXPECT_POINT_NEAR(per_vertex[1].position,
                     Point(200 + LineContents::kSampleRadius, 100 + offset));
   EXPECT_POINT_NEAR(per_vertex[2].position,
                     Point(100 - LineContents::kSampleRadius, 100 - offset));
   EXPECT_POINT_NEAR(per_vertex[3].position,
                     Point(200 + LineContents::kSampleRadius, 100 - offset));
  
   for (int i = 1; i < 4; ++i) {
     EXPECT_VECTOR3_NEAR(per_vertex[0].e0, per_vertex[i].e0) << i;
     EXPECT_VECTOR3_NEAR(per_vertex[0].e1, per_vertex[i].e1) << i;
     EXPECT_VECTOR3_NEAR(per_vertex[0].e2, per_vertex[i].e2) << i;
     EXPECT_VECTOR3_NEAR(per_vertex[0].e3, per_vertex[i].e3) << i;
   }
  
   EXPECT_EQ(CalculateLine(per_vertex[0], Point(0, 0)), 0.f);
   EXPECT_NEAR(CalculateLine(per_vertex[0], Point(150, 100 + offset)), 0.f,
               kEhCloseEnough);
   EXPECT_NEAR(CalculateLine(per_vertex[0], Point(150, 100 + offset * 0.5)),
               0.5f, kEhCloseEnough);
   EXPECT_NEAR(CalculateLine(per_vertex[0], Point(150, 100)), 1.f,
               kEhCloseEnough);
 }

References impeller::LineContents::CalculatePerVertex(), e0, e1, e2, e3, EXPECT_POINT_NEAR, EXPECT_VECTOR3_NEAR, impeller::kButt, impeller::kEhCloseEnough, impeller::LineContents::kSampleRadius, transform, and impeller::StrokeParameters::width.

◆ TEST() [239/523]

impeller::testing::TEST	(	LineContents	,
		CalculatePerVertexLimit
	)

Definition at line 125 of file line_contents_unittests.cc.

                                             {
   LineVertexShader::PerVertexData per_vertex[4];
   Scalar scale = 0.05;
   auto geometry = std::make_unique<LineGeometry>(
       /*p0=*/Point{100, 100},  //
       /*p1=*/Point{200, 100},  //
       StrokeParameters{
           .width = 10.f,
           .cap = Cap::kButt,
       });
   Matrix transform = Matrix::MakeTranslation({100, 100, 1.0}) *
                      Matrix::MakeScale({scale, scale, 1.0}) *
                      Matrix::MakeTranslation({-100, -100, 1.0});
  
   fml::StatusOr<LineContents::EffectiveLineParameters> status =
       LineContents::CalculatePerVertex(per_vertex, geometry.get(), transform);
  
   Scalar one_radius_size = std::max(LineContents::kSampleRadius / scale,
                                     LineContents::kSampleRadius);
   Scalar one_px_size = 1.f / scale;
   Scalar offset = one_px_size / 2.f + one_radius_size;
   ASSERT_TRUE(status.ok());
   EXPECT_NEAR(status.value().width, 20.f, kEhCloseEnough);
   EXPECT_NEAR(status.value().radius, one_px_size * LineContents::kSampleRadius,
               kEhCloseEnough);
   EXPECT_POINT_NEAR(per_vertex[0].position,
                     Point(100 - one_radius_size, 100 + offset));
   EXPECT_POINT_NEAR(per_vertex[1].position,
                     Point(200 + one_radius_size, 100 + offset));
   EXPECT_POINT_NEAR(per_vertex[2].position,
                     Point(100 - one_radius_size, 100 - offset));
   EXPECT_POINT_NEAR(per_vertex[3].position,
                     Point(200 + one_radius_size, 100 - offset));
  
   EXPECT_NEAR(CalculateLine(per_vertex[0], Point(150, 100)), 1.f,
               kEhCloseEnough);
   // EXPECT_NEAR(CalculateLine(per_vertex[0], Point(150, 100 +
   // one_px_size)), 1.f,
   //             kEhCloseEnough);
 }

References impeller::LineContents::CalculatePerVertex(), EXPECT_POINT_NEAR, impeller::kButt, impeller::kEhCloseEnough, impeller::LineContents::kSampleRadius, impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), transform, and impeller::StrokeParameters::width.

◆ TEST() [240/523]

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

Definition at line 37 of file line_contents_unittests.cc.

                            {
   Scalar width = 5.0f;
   auto geometry = std::make_unique<LineGeometry>(
       /*p0=*/Point{0, 0},      //
       /*p1=*/Point{100, 100},  //
       StrokeParameters{
           .width = width,
           .cap = Cap::kSquare,
       });
   std::unique_ptr<LineContents> contents =
       LineContents::Make(std::move(geometry), Color(1.f, 0.f, 0.f, 1.f));
   EXPECT_TRUE(contents);
   Entity entity;
   std::optional<Rect> coverage = contents->GetCoverage(entity);
   EXPECT_TRUE(coverage.has_value());
   if (coverage.has_value()) {
     Scalar lip = sqrt((width * width) / 2.f);
     EXPECT_EQ(*coverage,
               Rect::MakeXYWH(-lip, -lip, 100 + 2 * lip, 100 + 2 * lip));
   }
 }

References impeller::Entity::GetCoverage(), impeller::kSquare, impeller::LineContents::Make(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::StrokeParameters::width.

◆ TEST() [241/523]

impeller::testing::TEST	(	LineContents	,
		CreateCurveData
	)

Definition at line 102 of file line_contents_unittests.cc.

                                     {
   std::vector<uint8_t> data = LineContents::CreateCurveData(/*width=*/31,
                                                             /*radius=*/1,
                                                             /*scale=*/1);
   EXPECT_EQ(data.size(), 32u);
   EXPECT_NEAR(data[0] / 255.f, 0.f, kEhCloseEnough);
   EXPECT_NEAR(data[1] / 255.f, 0.5f, 0.02);
   EXPECT_NEAR(data[2] / 255.f, 1.f, kEhCloseEnough);
   EXPECT_NEAR(data[3] / 255.f, 1.f, kEhCloseEnough);
 }

References impeller::LineContents::CreateCurveData(), data, and impeller::kEhCloseEnough.

◆ TEST() [242/523]

impeller::testing::TEST	(	LineContents	,
		CreateCurveDataScaled
	)

Definition at line 113 of file line_contents_unittests.cc.

                                           {
   std::vector<uint8_t> data = LineContents::CreateCurveData(/*width=*/15.5,
                                                             /*radius=*/1,
                                                             /*scale=*/2);
   EXPECT_EQ(data.size(), 32u);
   EXPECT_NEAR(data[0] / 255.f, 0.f, kEhCloseEnough);
   EXPECT_NEAR(data[1] / 255.f, 0.5f, 0.02);
   EXPECT_NEAR(data[2] / 255.f, 1.f, kEhCloseEnough);
   EXPECT_NEAR(data[3] / 255.f, 1.f, kEhCloseEnough);
 }

References impeller::LineContents::CreateCurveData(), data, and impeller::kEhCloseEnough.

◆ TEST() [243/523]

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

Definition at line 65 of file matrix_filter_contents_unittests.cc.

                                            {
   MatrixFilterContents contents;
   contents.SetMatrix(Matrix::MakeScale({2.0, 2.0, 1.0}));
   FilterInput::Vector inputs = {
       FilterInput::Make(Rect::MakeXYWH(10, 10, 100, 100))};
   Entity entity;
   std::optional<Rect> coverage =
       contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
  
   ASSERT_EQ(coverage, Rect::MakeXYWH(20, 20, 200, 200));
 }

References impeller::MatrixFilterContents::GetFilterCoverage(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::MatrixFilterContents::SetMatrix().

◆ TEST() [244/523]

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

Definition at line 77 of file matrix_filter_contents_unittests.cc.

                                                  {
   MatrixFilterContents contents;
   FilterInput::Vector inputs = {
       FilterInput::Make(Rect::MakeXYWH(10, 10, 100, 100))};
   Entity entity;
   std::optional<Rect> coverage = contents.GetFilterCoverage(
       inputs, entity, /*effect_transform=*/Matrix::MakeScale({2.0, 2.0, 1.0}));
  
   ASSERT_EQ(coverage, Rect::MakeXYWH(10, 10, 100, 100));
 }

References impeller::MatrixFilterContents::GetFilterCoverage(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [245/523]

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

Definition at line 45 of file matrix_filter_contents_unittests.cc.

                                               {
   MatrixFilterContents contents;
   FilterInput::Vector inputs = {};
   Entity entity;
   std::optional<Rect> coverage =
       contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
   ASSERT_FALSE(coverage.has_value());
 }

References impeller::MatrixFilterContents::GetFilterCoverage().

◆ TEST() [246/523]

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

Definition at line 54 of file matrix_filter_contents_unittests.cc.

                                                {
   MatrixFilterContents contents;
   FilterInput::Vector inputs = {
       FilterInput::Make(Rect::MakeLTRB(10, 10, 110, 110))};
   Entity entity;
   std::optional<Rect> coverage =
       contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
  
   ASSERT_EQ(coverage, Rect::MakeLTRB(10, 10, 110, 110));
 }

References impeller::MatrixFilterContents::GetFilterCoverage(), impeller::FilterInput::Make(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [247/523]

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

Definition at line 28 of file matrix_unittests.cc.

                          {
   Matrix x;
   Matrix y = x;
   EXPECT_TRUE(x.Equals(y));
 }

References x.

◆ TEST() [248/523]

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

Definition at line 263 of file matrix_unittests.cc.

                                              {
   Matrix m = Matrix::MakeScale({-2, 1, 1});
  
   EXPECT_EQ(m.GetMaxBasisLengthXY(), 2);
  
   m = Matrix::MakeScale({1, -3, 1});
  
   EXPECT_EQ(m.GetMaxBasisLengthXY(), 3);
 }

References impeller::Matrix::GetMaxBasisLengthXY(), and impeller::Matrix::MakeScale().

◆ TEST() [249/523]

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

Definition at line 274 of file matrix_unittests.cc.

                                                               {
   Matrix m = Matrix::MakeScale({2.625e+20, 2.625e+20, 1});
   EXPECT_NEAR(m.GetMaxBasisLengthXY(), 2.625e+20, 1e+20);
  
   m = Matrix::MakeScale({2.625e-20, 2.625e-20, 1});
   EXPECT_NEAR(m.GetMaxBasisLengthXY(), 2.625e-20, 1e-20);
 }

References impeller::Matrix::GetMaxBasisLengthXY(), and impeller::Matrix::MakeScale().

◆ TEST() [250/523]

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

Definition at line 282 of file matrix_unittests.cc.

                                                                                {
   Matrix m = Matrix::MakeScale({2.625e+20, 2.625e+20, 1});
   m.e[0][1] = 2;
  
   EXPECT_TRUE(std::isinf(m.GetMaxBasisLengthXY()));
 }

References impeller::Matrix::e, impeller::Matrix::GetMaxBasisLengthXY(), and impeller::Matrix::MakeScale().

◆ TEST() [251/523]

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

Definition at line 58 of file matrix_unittests.cc.

                                  {
   EXPECT_FALSE(Matrix().HasPerspective());
  
   auto test = [](int index, bool expect) {
     Matrix matrix;
     EXPECT_FALSE(matrix.HasPerspective());
     matrix.m[index] = 0.5f;
     EXPECT_EQ(matrix.HasPerspective(), expect) << "index: " << index;
   };
  
   // clang-format off
   test( 0, false);  test( 1, false);  test( 2, false);  test( 3, true);
   test( 4, false);  test( 5, false);  test( 6, false);  test( 7, true);
   test( 8, false);  test( 9, false);  test(10, false);  test(11, true);
   test(12, false);  test(13, false);  test(14, false);  test(15, true);
   // clang-format on
 }

References impeller::Matrix::HasPerspective(), and impeller::Matrix::m.

◆ TEST() [252/523]

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

Definition at line 40 of file matrix_unittests.cc.

                                    {
   EXPECT_FALSE(Matrix().HasPerspective2D());
  
   auto test = [](int index, bool expect) {
     Matrix matrix;
     EXPECT_FALSE(matrix.HasPerspective2D());
     matrix.m[index] = 0.5f;
     EXPECT_EQ(matrix.HasPerspective2D(), expect) << "index: " << index;
   };
  
   // clang-format off
   test( 0, false);  test( 1, false);  test( 2, false);  test( 3, true);
   test( 4, false);  test( 5, false);  test( 6, false);  test( 7, true);
   test( 8, false);  test( 9, false);  test(10, false);  test(11, false);
   test(12, false);  test(13, false);  test(14, false);  test(15, true);
   // clang-format on
 }

References impeller::Matrix::HasPerspective2D(), and impeller::Matrix::m.

◆ TEST() [253/523]

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

Definition at line 76 of file matrix_unittests.cc.

                                  {
   EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).HasTranslation());
   EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).HasTranslation());
   EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).HasTranslation());
   EXPECT_FALSE(Matrix().HasTranslation());
 }

References impeller::Matrix::MakeTranslation().

◆ TEST() [254/523]

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

Definition at line 203 of file matrix_unittests.cc.

                             {
   EXPECT_TRUE(Matrix().IsAligned());
   EXPECT_TRUE(Matrix::MakeScale({1.0f, 1.0f, 2.0f}).IsAligned());
  
   // Begin Legacy tests transferred over from geometry_unittests.cc
   {
     auto m = Matrix::MakeTranslation({1, 2, 3});
     bool result = m.IsAligned();
     ASSERT_TRUE(result);
   }
  
   {
     auto m = Matrix::MakeRotationZ(Degrees{123});
     bool result = m.IsAligned();
     ASSERT_FALSE(result);
   }
   // End Legacy tests transferred over from geometry_unittests.cc
  
   auto test = [](int index, bool expect) {
     Matrix matrix;
     EXPECT_TRUE(matrix.IsAligned());
     matrix.m[index] = 0.5f;
     EXPECT_EQ(matrix.IsAligned(), expect) << "index: " << index;
   };
  
   // clang-format off
   test( 0, true);   test( 1, false);  test( 2, false);  test( 3, false);
   test( 4, false);  test( 5, true);   test( 6, false);  test( 7, false);
   test( 8, false);  test( 9, false);  test(10, true);   test(11, false);
   test(12, true);   test(13, true);   test(14, true);   test(15, false);
   // clang-format on
  
   // True for quadrant rotations from -250 to +250 full circles
   for (int i = -1000; i < 1000; i++) {
     Degrees d = Degrees(i * 90);
     Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
     EXPECT_TRUE(matrix.IsAligned()) << "degrees: " << d.degrees;
   }
  
   // False for half degree rotations from -999.5 to +1000.5 degrees
   for (int i = -1000; i < 1000; i++) {
     Degrees d = Degrees(i + 0.5f);
     Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
     EXPECT_FALSE(matrix.IsAligned()) << "degrees: " << d.degrees;
   }
 }

References impeller::Degrees::degrees, impeller::Matrix::IsAligned(), impeller::Matrix::m, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [255/523]

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

Definition at line 170 of file matrix_unittests.cc.

                               {
   EXPECT_TRUE(Matrix().IsAligned2D());
   EXPECT_TRUE(Matrix::MakeScale({1.0f, 1.0f, 2.0f}).IsAligned2D());
  
   auto test = [](int index, bool expect) {
     Matrix matrix;
     EXPECT_TRUE(matrix.IsAligned2D());
     matrix.m[index] = 0.5f;
     EXPECT_EQ(matrix.IsAligned2D(), expect) << "index: " << index;
   };
  
   // clang-format off
   test( 0, true);   test( 1, false);  test( 2, true);   test( 3, false);
   test( 4, false);  test( 5, true);   test( 6, true);   test( 7, false);
   test( 8, true);   test( 9, true);   test(10, true);   test(11, true);
   test(12, true);   test(13, true);   test(14, true);   test(15, false);
   // clang-format on
  
   // True for quadrant rotations from -250 to +250 full circles
   for (int i = -1000; i < 1000; i++) {
     Degrees d = Degrees(i * 90);
     Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
     EXPECT_TRUE(matrix.IsAligned2D()) << "degrees: " << d.degrees;
   }
  
   // False for half degree rotations from -999.5 to +1000.5 degrees
   for (int i = -1000; i < 1000; i++) {
     Degrees d = Degrees(i + 0.5f);
     Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
     EXPECT_FALSE(matrix.IsAligned2D()) << "degrees: " << d.degrees;
   }
 }

References impeller::Degrees::degrees, impeller::Matrix::IsAligned2D(), impeller::Matrix::m, impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeScale().

◆ TEST() [256/523]

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

Definition at line 132 of file matrix_unittests.cc.

                            {
   EXPECT_TRUE(Matrix().IsFinite());
  
   EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsFinite());
   EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsFinite());
  
   EXPECT_TRUE(Matrix::MakeRotationX(Degrees(30)).IsFinite());
   EXPECT_TRUE(Matrix::MakeRotationY(Degrees(30)).IsFinite());
   EXPECT_TRUE(Matrix::MakeRotationZ(Degrees(30)).IsFinite());
  
   EXPECT_TRUE(Matrix::MakeScale({0, 1, 1}).IsFinite());
   EXPECT_TRUE(Matrix::MakeScale({1, 0, 1}).IsFinite());
   EXPECT_TRUE(Matrix::MakeScale({1, 1, 0}).IsFinite());
  
   for (int i = 0; i < 16; i++) {
     {
       Matrix matrix;
       ASSERT_TRUE(matrix.IsFinite());
       matrix.m[i] = std::numeric_limits<Scalar>::infinity();
       ASSERT_FALSE(matrix.IsFinite());
     }
  
     {
       Matrix matrix;
       ASSERT_TRUE(matrix.IsFinite());
       matrix.m[i] = -std::numeric_limits<Scalar>::infinity();
       ASSERT_FALSE(matrix.IsFinite());
     }
  
     {
       Matrix matrix;
       ASSERT_TRUE(matrix.IsFinite());
       matrix.m[i] = -std::numeric_limits<Scalar>::quiet_NaN();
       ASSERT_FALSE(matrix.IsFinite());
     }
   }
 }

References impeller::Matrix::IsFinite(), impeller::Matrix::m, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [257/523]

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

Definition at line 105 of file matrix_unittests.cc.

                                              {
   EXPECT_TRUE(Matrix().IsInvertible());
   EXPECT_NE(Matrix().GetDeterminant(), 0.0f);
  
   EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsInvertible());
   EXPECT_NE(Matrix::MakeTranslation({100, 100, 0}).GetDeterminant(), 0.0f);
  
   EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsInvertible());
   EXPECT_NE(Matrix::MakeScale({100, 100, 1}).GetDeterminant(), 0.0f);
  
   EXPECT_TRUE(Matrix::MakeRotationX(Degrees(30)).IsInvertible());
   EXPECT_NE(Matrix::MakeRotationX(Degrees(30)).GetDeterminant(), 0.0f);
  
   EXPECT_TRUE(Matrix::MakeRotationY(Degrees(30)).IsInvertible());
   EXPECT_NE(Matrix::MakeRotationY(Degrees(30)).GetDeterminant(), 0.0f);
  
   EXPECT_TRUE(Matrix::MakeRotationZ(Degrees(30)).IsInvertible());
   EXPECT_NE(Matrix::MakeRotationZ(Degrees(30)).GetDeterminant(), 0.0f);
  
   EXPECT_FALSE(Matrix::MakeScale({0, 1, 1}).IsInvertible());
   EXPECT_EQ(Matrix::MakeScale({0, 1, 1}).GetDeterminant(), 0.0f);
   EXPECT_FALSE(Matrix::MakeScale({1, 0, 1}).IsInvertible());
   EXPECT_EQ(Matrix::MakeScale({1, 0, 1}).GetDeterminant(), 0.0f);
   EXPECT_FALSE(Matrix::MakeScale({1, 1, 0}).IsInvertible());
   EXPECT_EQ(Matrix::MakeScale({1, 1, 0}).GetDeterminant(), 0.0f);
 }

References impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [258/523]

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

Definition at line 83 of file matrix_unittests.cc.

                                     {
   EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsTranslationOnly());
   EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsTranslationScaleOnly());
   EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).IsTranslationOnly());
   EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).IsTranslationScaleOnly());
   EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).IsTranslationOnly());
   EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).IsTranslationScaleOnly());
   EXPECT_TRUE(Matrix().IsTranslationOnly());
   EXPECT_TRUE(Matrix().IsTranslationScaleOnly());
 }

References impeller::Matrix::MakeTranslation().

◆ TEST() [259/523]

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

Definition at line 94 of file matrix_unittests.cc.

                                          {
   EXPECT_FALSE(Matrix::MakeScale({100, 100, 1}).IsTranslationOnly());
   EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsTranslationScaleOnly());
   EXPECT_FALSE(Matrix::MakeScale({1, 100, 1}).IsTranslationOnly());
   EXPECT_TRUE(Matrix::MakeScale({1, 100, 1}).IsTranslationScaleOnly());
   EXPECT_FALSE(Matrix::MakeScale({100, 1, 1}).IsTranslationOnly());
   EXPECT_TRUE(Matrix::MakeScale({100, 1, 1}).IsTranslationScaleOnly());
   EXPECT_TRUE(Matrix().IsTranslationOnly());
   EXPECT_TRUE(Matrix().IsTranslationScaleOnly());
 }

References impeller::Matrix::MakeScale().

◆ TEST() [260/523]

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

Definition at line 301 of file matrix_unittests.cc.

                                      {
   EXPECT_TRUE(MatrixNear(
       Matrix::MakeTranslateScale({1, 1, 1.0 / 1024}, {10, 10, 1.0 / 1024}),
       Matrix::MakeTranslation({10, 10, 1.0 / 1024}) *
           Matrix::MakeScale({1, 1, 1.0 / 1024})));
  
   EXPECT_TRUE(MatrixNear(
       Matrix::MakeTranslateScale({2, 2, 2}, {10, 10, 0}),
       Matrix::MakeTranslation({10, 10, 0}) * Matrix::MakeScale({2, 2, 2})));
  
   EXPECT_TRUE(MatrixNear(
       Matrix::MakeTranslateScale({0, 0, 0}, {0, 0, 0}),
       Matrix::MakeTranslation({0, 0, 0}) * Matrix::MakeScale({0, 0, 0})));
 }

References impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslateScale(), impeller::Matrix::MakeTranslation(), and MatrixNear().

◆ TEST() [261/523]

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

Definition at line 15 of file matrix_unittests.cc.

                            {
   Matrix x(0.0, 0.0, 0.0, 1.0,  //
            1.0, 0.0, 0.0, 1.0,  //
            0.0, 1.0, 0.0, 1.0,  //
            1.0, 1.0, 0.0, 1.0);
   Matrix translate = Matrix::MakeTranslation({10, 20, 0});
   Matrix result = translate * x;
   EXPECT_TRUE(MatrixNear(result, Matrix(10.0, 20.0, 0.0, 1.0,  //
                                         11.0, 20.0, 0.0, 1.0,  //
                                         10.0, 21.0, 0.0, 1.0,  //
                                         11.0, 21.0, 0.0, 1.0)));
 }

References impeller::Matrix::MakeTranslation(), MatrixNear(), and x.

◆ TEST() [262/523]

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

Definition at line 34 of file matrix_unittests.cc.

                             {
   Matrix x;
   Matrix y = x.Translate({1, 0, 0});
   EXPECT_FALSE(x.Equals(y));
 }

References x.

◆ TEST() [263/523]

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

Definition at line 316 of file matrix_unittests.cc.

                         {
   Matrix x(1.0, 0.0, 4.0, 0.0,    //
            0.0, 1.0, 4.0, 0.0,    //
            6.0, 5.0, 111.0, 7.0,  //
            0.0, 0.0, 9.0, 1.0);
  
   EXPECT_TRUE(MatrixNear(x.To3x3(), Matrix()));
 }

References MatrixNear(), and x.

◆ TEST() [264/523]

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

Definition at line 250 of file matrix_unittests.cc.

                                       {
   Matrix matrix = Matrix::MakeColumn(
       // clang-format off
        2.0f,  3.0f,  5.0f,  7.0f,
       11.0f, 13.0f, 17.0f, 19.0f,
       23.0f, 29.0f, 31.0f, 37.0f,
       41.0f, 43.0f, 47.0f, 53.0f
       // clang-format on
   );
   EXPECT_EQ(matrix.TransformHomogenous({1.0f, -1.0f}),
             Vector3(32.0f, 33.0f, 41.0f));
 }

References impeller::Matrix::MakeColumn(), and impeller::Matrix::TransformHomogenous().

◆ TEST() [265/523]

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

Definition at line 289 of file matrix_unittests.cc.

                                            {
   Matrix m = Matrix::MakeRow(1.0, 0.0, 0.0, 10.0,  //
                              0.0, 1.0, 0.0, 20.0,  //
                              0.0, 0.0, 1.0, 0.0,   //
                              0.0, 2.0, 0.0, 30.0);
   Matrix result = m.Translate({100, 200});
   EXPECT_TRUE(MatrixNear(result, Matrix::MakeRow(1.0, 0.0, 0.0, 110.0,  //
                                                  0.0, 1.0, 0.0, 220.0,  //
                                                  0.0, 0.0, 1.0, 0.0,    //
                                                  0.0, 2.0, 0.0, 430.0)));
 }

References impeller::Matrix::MakeRow(), MatrixNear(), and impeller::Matrix::Translate().

◆ TEST() [266/523]

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

Definition at line 121 of file paint_unittests.cc.

                                                 {
   std::vector<flutter::DlColor> colors = {
       flutter::DlColor::kBlue(), flutter::DlColor::kGreen(),
       flutter::DlColor::kGreen(), flutter::DlColor::kRed()};
   std::vector<float> stops = {0.0, 0.5, 0.4, 1.0};
   const auto gradient =
       flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                          flutter::DlPoint(1.0, 1.0),   //
                                          4,                            //
                                          colors.data(),                //
                                          stops.data(),                 //
                                          flutter::DlTileMode::kClamp,  //
                                          nullptr                       //
       );
  
   std::vector<Color> converted_colors;
   std::vector<Scalar> converted_stops;
   Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                       converted_stops);
  
   // Value is clamped to 0.5
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 0.5f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[3], 1.0f));
 }

References impeller::Paint::ConvertStops(), and impeller::ScalarNearlyEqual().

◆ TEST() [267/523]

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

Definition at line 43 of file paint_unittests.cc.

                                   {
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kRed()};
   std::vector<float> stops = {0.5, 1.0};
   const auto gradient =
       flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                          flutter::DlPoint(1.0, 1.0),   //
                                          2,                            //
                                          colors.data(),                //
                                          stops.data(),                 //
                                          flutter::DlTileMode::kClamp,  //
                                          nullptr                       //
       );
  
   std::vector<Color> converted_colors;
   std::vector<Scalar> converted_stops;
   Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                       converted_stops);
  
   // First color is inserted as blue.
   ASSERT_TRUE(ScalarNearlyEqual(converted_colors[0].blue, 1.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
 }

References impeller::Paint::ConvertStops(), and impeller::ScalarNearlyEqual().

◆ TEST() [268/523]

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

Definition at line 69 of file paint_unittests.cc.

                                           {
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kRed()};
   std::vector<float> stops = {0.0, .5};
   const auto gradient =
       flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                          flutter::DlPoint(1.0, 1.0),   //
                                          2,                            //
                                          colors.data(),                //
                                          stops.data(),                 //
                                          flutter::DlTileMode::kClamp,  //
                                          nullptr                       //
       );
  
   std::vector<Color> converted_colors;
   std::vector<Scalar> converted_stops;
   Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                       converted_stops);
  
   // Last color is inserted as red.
   ASSERT_TRUE(ScalarNearlyEqual(converted_colors[2].red, 1.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
 }

References impeller::Paint::ConvertStops(), and impeller::ScalarNearlyEqual().

◆ TEST() [269/523]

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

Definition at line 17 of file paint_unittests.cc.

                                         {
   // Typical gradient.
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kRed(),
                                           flutter::DlColor::kGreen()};
   std::vector<float> stops = {0.0, 0.5, 1.0};
   const auto gradient =
       flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                          flutter::DlPoint(1.0, 1.0),   //
                                          3,                            //
                                          colors.data(),                //
                                          stops.data(),                 //
                                          flutter::DlTileMode::kClamp,  //
                                          nullptr                       //
       );
  
   std::vector<Color> converted_colors;
   std::vector<Scalar> converted_stops;
   Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                       converted_stops);
  
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
 }

References impeller::Paint::ConvertStops(), and impeller::ScalarNearlyEqual().

◆ TEST() [270/523]

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

Definition at line 95 of file paint_unittests.cc.

                                           {
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kGreen(),
                                           flutter::DlColor::kRed()};
   std::vector<float> stops = {0.0, 100, 1.0};
   const auto gradient =
       flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                          flutter::DlPoint(1.0, 1.0),   //
                                          3,                            //
                                          colors.data(),                //
                                          stops.data(),                 //
                                          flutter::DlTileMode::kClamp,  //
                                          nullptr                       //
       );
  
   std::vector<Color> converted_colors;
   std::vector<Scalar> converted_stops;
   Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                       converted_stops);
  
   // Value is clamped to 1.0
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 1.0f));
   ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
 }

References impeller::Paint::ConvertStops(), and impeller::ScalarNearlyEqual().

◆ TEST() [271/523]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSource
	)

Definition at line 157 of file path_source_unittests.cc.

                                            {
   DashedLinePathSource source(Point(10, 10), Point(30, 10), 5, 5);
  
   EXPECT_FALSE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
     EXPECT_CALL(receiver, LineTo(Point(15, 10)));
     EXPECT_CALL(receiver, MoveTo(Point(20, 10), false));
     EXPECT_CALL(receiver, LineTo(Point(25, 10)));
   }
  
   source.Dispatch(receiver);
 }

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [272/523]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSourceInvalidOffGaps
	)

Definition at line 216 of file path_source_unittests.cc.

                                                          {
   DashedLinePathSource source(Point(10, 10), Point(30, 10), 5, -1);
  
   EXPECT_FALSE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
     EXPECT_CALL(receiver, LineTo(Point(30, 10)));
   }
  
   source.Dispatch(receiver);
 }

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [273/523]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSourceInvalidOnRegion
	)

Definition at line 235 of file path_source_unittests.cc.

                                                           {
   DashedLinePathSource source(Point(10, 10), Point(30, 10), -1, 5);
  
   EXPECT_FALSE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
     EXPECT_CALL(receiver, LineTo(Point(30, 10)));
   }
  
   source.Dispatch(receiver);
 }

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [274/523]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSourceZeroOffGaps
	)

Definition at line 197 of file path_source_unittests.cc.

                                                       {
   DashedLinePathSource source(Point(10, 10), Point(30, 10), 5, 0);
  
   EXPECT_FALSE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
     EXPECT_CALL(receiver, LineTo(Point(30, 10)));
   }
  
   source.Dispatch(receiver);
 }

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [275/523]

impeller::testing::TEST	(	PathSourceTest	,
		DiffRoundRectSourceTest
	)

Definition at line 104 of file path_source_unittests.cc.

                                               {
   Rect outer_rect = Rect::MakeLTRB(10, 15, 200, 300);
   Rect inner_rect = Rect::MakeLTRB(50, 60, 100, 200);
   ASSERT_TRUE(outer_rect.Contains(inner_rect));
   RoundingRadii radii = {
       .top_left = Size(1, 11),
       .top_right = Size(2, 12),
       .bottom_left = Size(4, 14),
       .bottom_right = Size(3, 13),
   };
   RoundRect outer_rrect = RoundRect::MakeRectRadii(outer_rect, radii);
   RoundRect inner_rrect = RoundRect::MakeRectRadii(inner_rect, radii);
   DiffRoundRectPathSource source(outer_rrect, inner_rrect);
  
   EXPECT_FALSE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kOdd);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 200, 300));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(11, 15), true));
     EXPECT_CALL(receiver, LineTo(Point(198, 15)));
     EXPECT_CALL(receiver, ConicTo(Point(200, 15), Point(200, 27), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(200, 287)));
     EXPECT_CALL(receiver,
                 ConicTo(Point(200, 300), Point(197, 300), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(14, 300)));
     EXPECT_CALL(receiver, ConicTo(Point(10, 300), Point(10, 286), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(10, 26)));
     EXPECT_CALL(receiver, ConicTo(Point(10, 15), Point(11, 15), kSqrt2Over2));
     // RetiresOnSaturation keeps identical calls from matching each other
     EXPECT_CALL(receiver, Close()).RetiresOnSaturation();
  
     EXPECT_CALL(receiver, MoveTo(Point(51, 60), true));
     EXPECT_CALL(receiver, LineTo(Point(98, 60)));
     EXPECT_CALL(receiver, ConicTo(Point(100, 60), Point(100, 72), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(100, 187)));
     EXPECT_CALL(receiver,
                 ConicTo(Point(100, 200), Point(97, 200), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(54, 200)));
     EXPECT_CALL(receiver, ConicTo(Point(50, 200), Point(50, 186), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(50, 71)));
     EXPECT_CALL(receiver, ConicTo(Point(50, 60), Point(51, 60), kSqrt2Over2));
     // RetiresOnSaturation keeps identical calls from matching each other
     EXPECT_CALL(receiver, Close()).RetiresOnSaturation();
   }
  
   source.Dispatch(receiver);
 }

References impeller::Close(), impeller::TRect< T >::Contains(), impeller::DiffRoundRectPathSource::Dispatch(), impeller::DiffRoundRectPathSource::GetBounds(), impeller::DiffRoundRectPathSource::GetFillType(), impeller::DiffRoundRectPathSource::IsConvex(), impeller::kOdd, impeller::kSqrt2Over2, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::MoveTo(), and impeller::RoundingRadii::top_left.

◆ TEST() [276/523]

impeller::testing::TEST	(	PathSourceTest	,
		EllipseSourceTest
	)

Definition at line 45 of file path_source_unittests.cc.

                                         {
   Rect rect = Rect::MakeLTRB(10, 15, 20, 30);
   EllipsePathSource source(rect);
  
   EXPECT_TRUE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 20, 30));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 22.5), true));
     EXPECT_CALL(receiver, ConicTo(Point(10, 15), Point(15, 15), kSqrt2Over2));
     EXPECT_CALL(receiver, ConicTo(Point(20, 15), Point(20, 22.5), kSqrt2Over2));
     EXPECT_CALL(receiver, ConicTo(Point(20, 30), Point(15, 30), kSqrt2Over2));
     EXPECT_CALL(receiver, ConicTo(Point(10, 30), Point(10, 22.5), kSqrt2Over2));
     EXPECT_CALL(receiver, Close());
   }
  
   source.Dispatch(receiver);
 }

References impeller::Close(), impeller::EllipsePathSource::Dispatch(), impeller::EllipsePathSource::GetBounds(), impeller::EllipsePathSource::GetFillType(), impeller::EllipsePathSource::IsConvex(), impeller::kNonZero, impeller::kSqrt2Over2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [277/523]

impeller::testing::TEST	(	PathSourceTest	,
		EmptyDashedLinePathSource
	)

Definition at line 178 of file path_source_unittests.cc.

                                                 {
   DashedLinePathSource source(Point(10, 10), Point(10, 10), 5, 5);
  
   EXPECT_FALSE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 10, 10));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
     EXPECT_CALL(receiver, LineTo(Point(10, 10)));
   }
  
   source.Dispatch(receiver);
 }

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [278/523]

impeller::testing::TEST	(	PathSourceTest	,
		RectSourceTest
	)

Definition at line 21 of file path_source_unittests.cc.

                                      {
   Rect rect = Rect::MakeLTRB(10, 15, 20, 30);
   RectPathSource source(rect);
  
   EXPECT_TRUE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 20, 30));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(10, 15), true));
     EXPECT_CALL(receiver, LineTo(Point(20, 15)));
     EXPECT_CALL(receiver, LineTo(Point(20, 30)));
     EXPECT_CALL(receiver, LineTo(Point(10, 30)));
     EXPECT_CALL(receiver, LineTo(Point(10, 15)));
     EXPECT_CALL(receiver, Close());
   }
  
   source.Dispatch(receiver);
 }

References impeller::Close(), impeller::RectPathSource::Dispatch(), impeller::RectPathSource::GetBounds(), impeller::RectPathSource::GetFillType(), impeller::RectPathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [279/523]

impeller::testing::TEST	(	PathSourceTest	,
		RoundRectSourceTest
	)

Definition at line 69 of file path_source_unittests.cc.

                                           {
   Rect rect = Rect::MakeLTRB(10, 15, 40, 60);
   RoundingRadii radii = {
       .top_left = Size(1, 11),
       .top_right = Size(2, 12),
       .bottom_left = Size(4, 14),
       .bottom_right = Size(3, 13),
   };
   RoundRect round_rect = RoundRect::MakeRectRadii(rect, radii);
   RoundRectPathSource source(round_rect);
  
   EXPECT_TRUE(source.IsConvex());
   EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
   EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 40, 60));
  
   ::testing::StrictMock<DlPathReceiverMock> receiver;
  
   {
     ::testing::Sequence sequence;
  
     EXPECT_CALL(receiver, MoveTo(Point(11, 15), true));
     EXPECT_CALL(receiver, LineTo(Point(38, 15)));
     EXPECT_CALL(receiver, ConicTo(Point(40, 15), Point(40, 27), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(40, 47)));
     EXPECT_CALL(receiver, ConicTo(Point(40, 60), Point(37, 60), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(14, 60)));
     EXPECT_CALL(receiver, ConicTo(Point(10, 60), Point(10, 46), kSqrt2Over2));
     EXPECT_CALL(receiver, LineTo(Point(10, 26)));
     EXPECT_CALL(receiver, ConicTo(Point(10, 15), Point(11, 15), kSqrt2Over2));
     EXPECT_CALL(receiver, Close());
   }
  
   source.Dispatch(receiver);
 }

References impeller::Close(), impeller::RoundRectPathSource::Dispatch(), impeller::RoundRectPathSource::GetBounds(), impeller::RoundRectPathSource::GetFillType(), impeller::RoundRectPathSource::IsConvex(), impeller::kNonZero, impeller::kSqrt2Over2, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::MoveTo(), and impeller::RoundingRadii::top_left.

◆ TEST() [280/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		ComplexPath
	)

Definition at line 396 of file path_tessellator_unittests.cc.

                                        {
   PathTessellator::Quad quad{{10, 10}, {20, 20}, {20, 10}};
   PathTessellator::Conic conic{{20, 10}, {30, 20}, {30, 10}, 2.0f};
   PathTessellator::Cubic cubic{{30, 10}, {40, 20}, {40, 10}, {42, 15}};
  
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.LineTo({10, 10});
   builder.QuadraticCurveTo(quad.cp, quad.p2);
   builder.ConicCurveTo(conic.cp, conic.p2, conic.weight);
   builder.CubicCurveTo(cubic.cp1, cubic.cp2, cubic.p2);
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordQuad(quad.p1, quad.cp, quad.p2));
     EXPECT_CALL(mock_receiver,
                 RecordConic(conic.p1, conic.cp, conic.p2, conic.weight));
     EXPECT_CALL(mock_receiver,
                 RecordCubic(cubic.p1, cubic.cp1, cubic.cp2, cubic.p2));
     EXPECT_CALL(mock_receiver, RecordLine(cubic.p2, Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 25u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     {
       EXPECT_CALL(mock_writer, Write(quad.Solve(1 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(2 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(3 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(4 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.p2));
     }
     {
       EXPECT_CALL(mock_writer, Write(conic.Solve(1 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(2 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(3 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(4 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(5 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(6 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(7 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.p2));
     }
     {
       EXPECT_CALL(mock_writer, Write(cubic.Solve(1 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(2 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(3 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(4 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(5 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(6 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(7 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(8 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.p2));
     }
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [281/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		ComplexPathTrailingMoveTo
	)

Definition at line 471 of file path_tessellator_unittests.cc.

                                                      {
   PathTessellator::Quad quad{{10, 10}, {20, 20}, {20, 10}};
   PathTessellator::Conic conic{{20, 10}, {30, 20}, {30, 10}, 2.0f};
   PathTessellator::Cubic cubic{{30, 10}, {40, 20}, {40, 10}, {42, 15}};
  
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.LineTo({10, 10});
   builder.QuadraticCurveTo(quad.cp, quad.p2);
   builder.ConicCurveTo(conic.cp, conic.p2, conic.weight);
   builder.CubicCurveTo(cubic.cp1, cubic.cp2, cubic.p2);
   builder.Close();
   builder.MoveTo({500, 100});
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordQuad(quad.p1, quad.cp, quad.p2));
     EXPECT_CALL(mock_receiver,
                 RecordConic(conic.p1, conic.cp, conic.p2, conic.weight));
     EXPECT_CALL(mock_receiver,
                 RecordCubic(cubic.p1, cubic.cp1, cubic.cp2, cubic.p2));
     EXPECT_CALL(mock_receiver, RecordLine(cubic.p2, Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 25u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     {
       EXPECT_CALL(mock_writer, Write(quad.Solve(1 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(2 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(3 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(4 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.p2));
     }
     {
       EXPECT_CALL(mock_writer, Write(conic.Solve(1 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(2 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(3 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(4 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(5 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(6 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.Solve(7 / 8.0f)));
       EXPECT_CALL(mock_writer, Write(conic.p2));
     }
     {
       EXPECT_CALL(mock_writer, Write(cubic.Solve(1 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(2 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(3 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(4 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(5 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(6 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(7 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.Solve(8 / 9.0f)));
       EXPECT_CALL(mock_writer, Write(cubic.p2));
     }
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [282/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		ConicToLineToOptimization
	)

Definition at line 269 of file path_tessellator_unittests.cc.

                                                      {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   // CP == P1
   builder.ConicCurveTo({0, 0}, {10, 10}, 2.0f);
   // CP == P2
   builder.ConicCurveTo({20, 10}, {20, 10}, 2.0f);
   // weight == 0
   builder.ConicCurveTo({20, 0}, {10, 0}, 0.0f);
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(20, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(20, 10), Point(10, 0)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 0), Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 5u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     EXPECT_CALL(mock_writer, Write(Point(20, 10)));
     EXPECT_CALL(mock_writer, Write(Point(10, 0)));
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [283/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		ConicToQuadToOptimization
	)

Definition at line 313 of file path_tessellator_unittests.cc.

                                                      {
   // The conic below will simplify to this quad
   PathTessellator::Quad quad{{0, 0}, {10, 0}, {0, 10}};
  
   flutter::DlPathBuilder builder;
   builder.MoveTo(quad.p1);
   // weight == 1
   builder.ConicCurveTo(quad.cp, quad.p2, 1.0f);
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver, BeginContour(quad.p1, /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordQuad(quad.p1, quad.cp, quad.p2));
     EXPECT_CALL(mock_receiver, RecordLine(quad.p2, quad.p1));
     EXPECT_CALL(mock_receiver, EndContour(quad.p1, /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 7u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(quad.p1));
     {
       EXPECT_CALL(mock_writer, Write(quad.Solve(1 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(2 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(3 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.Solve(4 / 5.0f)));
       EXPECT_CALL(mock_writer, Write(quad.p2));
     }
     EXPECT_CALL(mock_writer, Write(quad.p1));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [284/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		DegenerateSegmentsPath
	)

Definition at line 191 of file path_tessellator_unittests.cc.

                                                   {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.LineTo({0, 0});
   builder.LineTo({0, 0});
   builder.QuadraticCurveTo({0, 0}, {0, 0});
   builder.QuadraticCurveTo({0, 0}, {0, 0});
   builder.ConicCurveTo({0, 0}, {0, 0}, 12.0f);
   builder.ConicCurveTo({0, 0}, {0, 0}, 12.0f);
   builder.CubicCurveTo({0, 0}, {0, 0}, {0, 0});
   builder.CubicCurveTo({0, 0}, {0, 0}, {0, 0});
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 1u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [285/523]

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

Definition at line 42 of file path_tessellator_unittests.cc.

                                      {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 0u);
   EXPECT_EQ(contours, 0u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [286/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		EmptyPathMultipleMoveTo
	)

Definition at line 58 of file path_tessellator_unittests.cc.

                                                    {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.MoveTo({10, 10});
   builder.MoveTo({20, 20});
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 0u);
   EXPECT_EQ(contours, 0u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [287/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		LinearConicToPointCount
	)

Definition at line 559 of file path_tessellator_unittests.cc.

                                                    {
   flutter::DlPathBuilder builder;
   builder.MoveTo({316.3, 121.5});
   builder.ConicCurveTo({316.4, 121.5}, {316.5, 121.5}, 2.0f);
   builder.Close();
   auto path = builder.TakePath();
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 2.0f);
   EXPECT_EQ(points, 3u);
   EXPECT_EQ(contours, 1u);
 }

References contours, impeller::PathTessellator::CountFillStorage(), and points.

◆ TEST() [288/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		LinearCubicToPointCount
	)

Definition at line 571 of file path_tessellator_unittests.cc.

                                                    {
   flutter::DlPathBuilder builder;
   builder.MoveTo({316.3, 121.5});
   builder.CubicCurveTo({316.4, 121.5}, {316.5, 121.5}, {316.6, 121.5});
   builder.Close();
   auto path = builder.TakePath();
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 2.0f);
   EXPECT_EQ(points, 3u);
   EXPECT_EQ(contours, 1u);
 }

References contours, impeller::PathTessellator::CountFillStorage(), and points.

◆ TEST() [289/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		LinearQuadToPointCount
	)

Definition at line 547 of file path_tessellator_unittests.cc.

                                                   {
   flutter::DlPathBuilder builder;
   builder.MoveTo({316.3, 121.5});
   builder.QuadraticCurveTo({316.4, 121.5}, {316.5, 121.5});
   builder.Close();
   auto path = builder.TakePath();
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 2.0f);
   EXPECT_EQ(points, 3u);
   EXPECT_EQ(contours, 1u);
 }

References contours, impeller::PathTessellator::CountFillStorage(), and points.

◆ TEST() [290/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		QuadToLineToOptimization
	)

Definition at line 229 of file path_tessellator_unittests.cc.

                                                     {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   // CP == P1
   builder.QuadraticCurveTo({0, 0}, {10, 10});
   // CP == P2
   builder.QuadraticCurveTo({20, 10}, {20, 10});
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(20, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(20, 10), Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 4u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     EXPECT_CALL(mock_writer, Write(Point(20, 10)));
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [291/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimpleClosedPath
	)

Definition at line 76 of file path_tessellator_unittests.cc.

                                             {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.LineTo({10, 10});
   builder.LineTo({0, 20});
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 4u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     EXPECT_CALL(mock_writer, Write(Point(0, 20)));
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [292/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimplePathMultipleMoveTo
	)

Definition at line 357 of file path_tessellator_unittests.cc.

                                                     {
   flutter::DlPathBuilder builder;
   builder.MoveTo({500, 100});
   builder.MoveTo({0, 0});
   builder.LineTo({10, 10});
   builder.LineTo({0, 20});
   builder.Close();
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 4u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     EXPECT_CALL(mock_writer, Write(Point(0, 20)));
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [293/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimplePathTrailingMoveTo
	)

Definition at line 152 of file path_tessellator_unittests.cc.

                                                     {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.LineTo({10, 10});
   builder.LineTo({0, 20});
   builder.Close();
   builder.MoveTo({500, 100});
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/true));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 4u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     EXPECT_CALL(mock_writer, Write(Point(0, 20)));
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [294/523]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimpleUnclosedPath
	)

Definition at line 114 of file path_tessellator_unittests.cc.

                                               {
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.LineTo({10, 10});
   builder.LineTo({0, 20});
   // Close not really needed for filled paths
   flutter::DlPath path = builder.TakePath();
  
   ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_receiver,
                 BeginContour(Point(0, 0), /*will_be_closed=*/false));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
     EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
     EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/false));
   }
   PathTessellator::PathToFilledSegments(path, mock_receiver);
  
   auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
   EXPECT_EQ(points, 4u);
   EXPECT_EQ(contours, 1u);
  
   ::testing::StrictMock<MockPathVertexWriter> mock_writer;
   {
     ::testing::InSequence sequence;
  
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, Write(Point(10, 10)));
     EXPECT_CALL(mock_writer, Write(Point(0, 20)));
     EXPECT_CALL(mock_writer, Write(Point(0, 0)));
     EXPECT_CALL(mock_writer, EndContour());
   }
   PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
 }

References contours, impeller::PathTessellator::CountFillStorage(), impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), and points.

◆ TEST() [295/523]

impeller::testing::TEST	(	PipelineCacheDataVKTest	,
		CanCreateFromDeviceProperties
	)

Definition at line 77 of file pipeline_cache_data_vk_unittests.cc.

                                                              {
   vk::PhysicalDeviceProperties props;
   std::array<uint8_t, 16> uuid{
       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
   };
   props.pipelineCacheUUID = uuid;
   props.deviceID = 10;
   props.vendorID = 11;
   props.driverVersion = 12;
   PipelineCacheHeaderVK header(props, 99);
   EXPECT_EQ(uuid.size(), std::size(header.uuid));
   EXPECT_EQ(props.deviceID, header.device_id);
   EXPECT_EQ(props.vendorID, header.vendor_id);
   EXPECT_EQ(props.driverVersion, header.driver_version);
   for (size_t i = 0; i < uuid.size(); i++) {
     EXPECT_EQ(header.uuid[i], uuid.at(i));
   }
 }

References impeller::PipelineCacheHeaderVK::device_id, impeller::PipelineCacheHeaderVK::driver_version, impeller::PipelineCacheHeaderVK::uuid, and impeller::PipelineCacheHeaderVK::vendor_id.

◆ TEST() [296/523]

impeller::testing::TEST	(	PipelineCacheDataVKTest	,
		CanTestHeaderCompatibility
	)

Definition at line 17 of file pipeline_cache_data_vk_unittests.cc.

                                                           {
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     EXPECT_EQ(a.abi, sizeof(void*));
 #ifdef FML_ARCH_CPU_64_BITS
     EXPECT_EQ(a.abi, 8u);
 #elif FML_ARCH_CPU_32_BITS
     EXPECT_EQ(a.abi, 4u);
 #endif
     EXPECT_TRUE(a.IsCompatibleWith(b));
   }
   // Different data sizes don't matter.
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     a.data_size = b.data_size + 100u;
     EXPECT_TRUE(a.IsCompatibleWith(b));
   }
   // Magic, Driver, vendor, ABI, and UUID matter.
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     b.magic = 100;
     EXPECT_FALSE(a.IsCompatibleWith(b));
   }
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     b.driver_version = 100;
     EXPECT_FALSE(a.IsCompatibleWith(b));
   }
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     b.vendor_id = 100;
     EXPECT_FALSE(a.IsCompatibleWith(b));
   }
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     b.device_id = 100;
     EXPECT_FALSE(a.IsCompatibleWith(b));
   }
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     b.abi = a.abi / 2u;
     EXPECT_FALSE(a.IsCompatibleWith(b));
   }
   {
     PipelineCacheHeaderVK a;
     PipelineCacheHeaderVK b;
     for (size_t i = 0; i < VK_UUID_SIZE; i++) {
       b.uuid[i] = a.uuid[i] + 1;
     }
     EXPECT_FALSE(a.IsCompatibleWith(b));
   }
 }

References impeller::PipelineCacheHeaderVK::abi, impeller::saturated::b, impeller::PipelineCacheHeaderVK::data_size, impeller::PipelineCacheHeaderVK::IsCompatibleWith(), and impeller::PipelineCacheHeaderVK::uuid.

◆ TEST() [297/523]

impeller::testing::TEST	(	PipelineCacheDataVKTest	,
		WritesIncompleteCacheData
	)

Definition at line 96 of file pipeline_cache_data_vk_unittests.cc.

                                                          {
   fml::ScopedTemporaryDirectory temp_dir;
   auto context = MockVulkanContextBuilder().Build();
   auto cache = context->GetDevice().createPipelineCacheUnique({});
   const auto& caps = CapabilitiesVK::Cast(*context->GetCapabilities());
  
   ASSERT_TRUE(PipelineCacheDataPersist(
       temp_dir.fd(), caps.GetPhysicalDeviceProperties(), cache.value));
  
   std::unique_ptr<fml::FileMapping> mapping = fml::FileMapping::CreateReadOnly(
       temp_dir.fd(), "flutter.impeller.vkcache");
   ASSERT_TRUE(mapping);
   PipelineCacheHeaderVK header;
   ASSERT_GE(mapping->GetSize(), sizeof(header));
   std::memcpy(&header, mapping->GetMapping(), sizeof(header));
   ASSERT_EQ(mapping->GetSize(), sizeof(header) + header.data_size);
 }

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), impeller::PipelineCacheHeaderVK::data_size, and impeller::PipelineCacheDataPersist().

◆ TEST() [298/523]

impeller::testing::TEST	(	PipelineDescriptorTest	,
		PrimitiveTypeHashEquality
	)

Definition at line 13 of file pipeline_descriptor_unittests.cc.

                                                         {
   PipelineDescriptor descA;
   PipelineDescriptor descB;
  
   ASSERT_TRUE(descA.IsEqual(descB));
   ASSERT_EQ(descA.GetHash(), descB.GetHash());
  
   descA.SetPrimitiveType(PrimitiveType::kTriangleStrip);
  
   ASSERT_FALSE(descA.IsEqual(descB));
   ASSERT_NE(descA.GetHash(), descB.GetHash());
 }

References impeller::PipelineDescriptor::GetHash(), impeller::PipelineDescriptor::IsEqual(), impeller::kTriangleStrip, and impeller::PipelineDescriptor::SetPrimitiveType().

◆ TEST() [299/523]

impeller::testing::TEST	(	PoolTest	,
		Overload
	)

Definition at line 47 of file pool_unittests.cc.

                          {
   Pool<Foobar> pool(1'000);
   {
     std::vector<std::shared_ptr<Foobar>> values;
     values.reserve(20);
     for (int i = 0; i < 20; i++) {
       values.push_back(pool.Grab());
     }
     for (const auto& value : values) {
       value->SetSize(100);
       pool.Recycle(value);
     }
   }
   EXPECT_EQ(pool.GetSize(), 1'000u);
 }

References impeller::Pool< T >::GetSize(), impeller::Pool< T >::Grab(), impeller::Pool< T >::Recycle(), and value.

◆ TEST() [300/523]

impeller::testing::TEST	(	PoolTest	,
		Simple
	)

Definition at line 33 of file pool_unittests.cc.

                        {
   Pool<Foobar> pool(1'000);
   {
     auto grabbed = pool.Grab();
     grabbed->SetSize(123);
     pool.Recycle(grabbed);
     EXPECT_EQ(pool.GetSize(), 123u);
   }
   auto grabbed = pool.Grab();
   EXPECT_EQ(grabbed->GetSize(), 123u);
   EXPECT_TRUE(grabbed->GetIsReset());
   EXPECT_EQ(pool.GetSize(), 0u);
 }

References impeller::Pool< T >::GetSize(), impeller::Pool< T >::Grab(), and impeller::Pool< T >::Recycle().

◆ TEST() [301/523]

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

Definition at line 1316 of file rect_unittests.cc.

                                       {
   auto rect1 =
       Rect::MakeXYWH(472.599945f, 440.999969f, 1102.80005f, 654.000061f);
   auto rect2 = Rect::MakeXYWH(724.f, 618.f, 600.f, 300.f);
   EXPECT_TRUE(rect1.Contains(rect2));
 }

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [302/523]

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

Definition at line 899 of file rect_unittests.cc.

                                            {
   IRect rect = IRect::MakeLTRB(50, 50, 100, 100);
  
   auto test = [&rect](int64_t l, int64_t t, int64_t r, int64_t b,
                       const std::string& label) {
     EXPECT_FALSE(IRect::MakeLTRB(l, b, r, t).IntersectsWithRect(rect))
         << label << " with Top/Bottom swapped";
     EXPECT_FALSE(IRect::MakeLTRB(r, b, l, t).IntersectsWithRect(rect))
         << label << " with Left/Right swapped";
     EXPECT_FALSE(IRect::MakeLTRB(r, t, l, b).IntersectsWithRect(rect))
         << label << " with all sides swapped";
   };
  
   test(20, 20, 30, 30, "Above and Left");
   test(70, 20, 80, 30, "Above");
   test(120, 20, 130, 30, "Above and Right");
   test(120, 70, 130, 80, "Right");
   test(120, 120, 130, 130, "Below and Right");
   test(70, 120, 80, 130, "Below");
   test(20, 120, 30, 130, "Below and Left");
   test(20, 70, 30, 80, "Left");
  
   test(70, 70, 80, 80, "Inside");
  
   test(40, 70, 60, 80, "Straddling Left");
   test(70, 40, 80, 60, "Straddling Top");
   test(90, 70, 110, 80, "Straddling Right");
   test(70, 90, 80, 110, "Straddling Bottom");
 }

References impeller::saturated::b, and impeller::TRect< T >::MakeLTRB().

◆ TEST() [303/523]

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

Definition at line 869 of file rect_unittests.cc.

                                           {
   Rect rect = Rect::MakeLTRB(50, 50, 100, 100);
  
   auto test = [&rect](Scalar l, Scalar t, Scalar r, Scalar b,
                       const std::string& label) {
     EXPECT_FALSE(Rect::MakeLTRB(l, b, r, t).IntersectsWithRect(rect))
         << label << " with Top/Bottom swapped";
     EXPECT_FALSE(Rect::MakeLTRB(r, b, l, t).IntersectsWithRect(rect))
         << label << " with Left/Right swapped";
     EXPECT_FALSE(Rect::MakeLTRB(r, t, l, b).IntersectsWithRect(rect))
         << label << " with all sides swapped";
   };
  
   test(20, 20, 30, 30, "Above and Left");
   test(70, 20, 80, 30, "Above");
   test(120, 20, 130, 30, "Above and Right");
   test(120, 70, 130, 80, "Right");
   test(120, 120, 130, 130, "Below and Right");
   test(70, 120, 80, 130, "Below");
   test(20, 120, 30, 130, "Below and Left");
   test(20, 70, 30, 80, "Left");
  
   test(70, 70, 80, 80, "Inside");
  
   test(40, 70, 60, 80, "Straddling Left");
   test(70, 40, 80, 60, "Straddling Top");
   test(90, 70, 110, 80, "Straddling Right");
   test(70, 90, 80, 110, "Straddling Bottom");
 }

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

◆ TEST() [304/523]

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

Definition at line 1239 of file rect_unittests.cc.

                           {
   EXPECT_EQ(Rect::MakeXYWH(10, 30, 20, 20).GetCenter(), Point(20, 40));
   EXPECT_EQ(Rect::MakeXYWH(10, 30, 20, 19).GetCenter(), Point(20, 39.5));
   EXPECT_EQ(Rect::MakeMaximum().GetCenter(), Point(0, 0));
  
   // Note that we expect a Point as the answer from an IRect
   EXPECT_EQ(IRect::MakeXYWH(10, 30, 20, 20).GetCenter(), Point(20, 40));
   EXPECT_EQ(IRect::MakeXYWH(10, 30, 20, 19).GetCenter(), Point(20, 39.5));
   EXPECT_EQ(IRect::MakeMaximum().GetCenter(), Point(0, 0));
 }

References impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< T >::MakeMaximum(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [305/523]

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

Definition at line 1025 of file rect_unittests.cc.

                           {
   EXPECT_EQ(IRect::MakeXYWH(0, 0, 100, 200).Area(), 20000);
   EXPECT_EQ(IRect::MakeXYWH(10, 20, 100, 200).Area(), 20000);
   EXPECT_EQ(IRect::MakeXYWH(0, 0, 200, 100).Area(), 20000);
   EXPECT_EQ(IRect::MakeXYWH(10, 20, 200, 100).Area(), 20000);
   EXPECT_EQ(IRect::MakeXYWH(0, 0, 100, 100).Area(), 10000);
   EXPECT_EQ(IRect::MakeXYWH(10, 20, 100, 100).Area(), 10000);
 }

References impeller::TRect< T >::MakeXYWH().

◆ TEST() [306/523]

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

Definition at line 2404 of file rect_unittests.cc.

                                              {
   auto check_empty_flips = [](const IRect& rect, const IPoint& point,
                               const std::string& label) {
     ASSERT_FALSE(rect.IsEmpty());
  
     EXPECT_FALSE(flip_lr(rect).ContainsInclusive(point)) << label;
     EXPECT_FALSE(flip_tb(rect).ContainsInclusive(point)) << label;
     EXPECT_FALSE(flip_lrtb(rect).ContainsInclusive(point)) << label;
   };
  
   auto test_inside = [&check_empty_flips](const IRect& rect,
                                           const IPoint& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_TRUE(rect.ContainsInclusive(point)) << label;
     check_empty_flips(rect, point, label);
   };
  
   auto test_outside = [&check_empty_flips](const IRect& rect,
                                            const IPoint& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_FALSE(rect.ContainsInclusive(point)) << label;
     check_empty_flips(rect, point, label);
   };
  
   {
     // Origin is inclusive
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(100, 100);
  
     test_inside(r, p);
   }
   {
     // Size is inclusive
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(200, 200);
  
     test_inside(r, p);
   }
   {
     // Size + "epsilon" is exclusive
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(201, 201);
  
     test_outside(r, p);
   }
   {
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(99, 99);
  
     test_outside(r, p);
   }
   {
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(199, 199);
  
     test_inside(r, p);
   }
  
   {
     auto r = IRect::MakeMaximum();
     auto p = IPoint(199, 199);
  
     test_inside(r, p);
   }
 }

References impeller::TRect< T >::ContainsInclusive(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [307/523]

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

Definition at line 2242 of file rect_unittests.cc.

                                     {
   auto check_empty_flips = [](const IRect& rect, const IPoint& point,
                               const std::string& label) {
     ASSERT_FALSE(rect.IsEmpty());
  
     EXPECT_FALSE(flip_lr(rect).Contains(point)) << label;
     EXPECT_FALSE(flip_tb(rect).Contains(point)) << label;
     EXPECT_FALSE(flip_lrtb(rect).Contains(point)) << label;
   };
  
   auto test_inside = [&check_empty_flips](const IRect& rect,
                                           const IPoint& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_TRUE(rect.Contains(point)) << label;
     check_empty_flips(rect, point, label);
   };
  
   auto test_outside = [&check_empty_flips](const IRect& rect,
                                            const IPoint& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_FALSE(rect.Contains(point)) << label;
     check_empty_flips(rect, point, label);
   };
  
   {
     // Origin is inclusive
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(100, 100);
  
     test_inside(r, p);
   }
   {
     // Size is exclusive
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(200, 200);
  
     test_outside(r, p);
   }
   {
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(99, 99);
  
     test_outside(r, p);
   }
   {
     auto r = IRect::MakeXYWH(100, 100, 100, 100);
     auto p = IPoint(199, 199);
  
     test_inside(r, p);
   }
  
   {
     auto r = IRect::MakeMaximum();
     auto p = IPoint(199, 199);
  
     test_inside(r, p);
   }
 }

References impeller::TRect< T >::Contains(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [308/523]

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

Definition at line 2595 of file rect_unittests.cc.

                                    {
   auto check_empty_flips = [](const IRect& a, const IRect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // test b rects are allowed to have 0 w/h, but not be backwards
     ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
  
     // unflipped a vs flipped (empty) b yields true
     EXPECT_TRUE(a.Contains(flip_lr(b))) << label;
     EXPECT_TRUE(a.Contains(flip_tb(b))) << label;
     EXPECT_TRUE(a.Contains(flip_lrtb(b))) << label;
  
     // flipped (empty) a vs unflipped b yields false
     EXPECT_FALSE(flip_lr(a).Contains(b)) << label;
     EXPECT_FALSE(flip_tb(a).Contains(b)) << label;
     EXPECT_FALSE(flip_lrtb(a).Contains(b)) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_FALSE(flip_lr(a).Contains(flip_lr(b))) << label;
     EXPECT_FALSE(flip_tb(a).Contains(flip_tb(b))) << label;
     EXPECT_FALSE(flip_lrtb(a).Contains(flip_lrtb(b))) << label;
   };
  
   auto test_inside = [&check_empty_flips](const IRect& a, const IRect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // test b rects are allowed to have 0 w/h, but not be backwards
     ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
  
     std::stringstream stream;
     stream << a << " contains " << b;
     auto label = stream.str();
  
     EXPECT_TRUE(a.Contains(b)) << label;
     check_empty_flips(a, b, label);
   };
  
   auto test_not_inside = [&check_empty_flips](const IRect& a, const IRect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // If b was empty, it would be contained and should not be tested with
     // this function - use |test_inside| instead.
     ASSERT_FALSE(b.IsEmpty()) << b;
  
     std::stringstream stream;
     stream << a << " contains " << b;
     auto label = stream.str();
  
     EXPECT_FALSE(a.Contains(b)) << label;
     check_empty_flips(a, b, label);
   };
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
  
     test_inside(a, a);
   }
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(0, 0, 0, 0);
  
     test_inside(a, b);
   }
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(150, 150, 20, 20);
  
     test_inside(a, b);
   }
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(150, 150, 100, 100);
  
     test_not_inside(a, b);
   }
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(50, 50, 100, 100);
  
     test_not_inside(a, b);
   }
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(0, 0, 300, 300);
  
     test_not_inside(a, b);
   }
   {
     auto a = IRect::MakeMaximum();
     auto b = IRect::MakeXYWH(0, 0, 300, 300);
  
     test_inside(a, b);
   }
 }

References impeller::saturated::b, impeller::TRect< T >::Contains(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [309/523]

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

Definition at line 686 of file rect_unittests.cc.

                           {
   IRect rect = IRect::MakeLTRB(5, 10, 20, 25);
   IRect copy = rect;
  
   EXPECT_EQ(rect, copy);
   EXPECT_EQ(copy.GetLeft(), 5);
   EXPECT_EQ(copy.GetTop(), 10);
   EXPECT_EQ(copy.GetRight(), 20);
   EXPECT_EQ(copy.GetBottom(), 25);
   EXPECT_EQ(copy.GetX(), 5);
   EXPECT_EQ(copy.GetY(), 10);
   EXPECT_EQ(copy.GetWidth(), 15);
   EXPECT_EQ(copy.GetHeight(), 15);
   EXPECT_FALSE(copy.IsEmpty());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [310/523]

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

Definition at line 2840 of file rect_unittests.cc.

                             {
   IRect cull_rect = IRect::MakeLTRB(20, 20, 40, 40);
  
   auto check_empty_flips = [&cull_rect](const IRect& diff_rect,
                                         const std::string& label) {
     EXPECT_FALSE(diff_rect.IsEmpty());
     EXPECT_FALSE(cull_rect.IsEmpty());
  
     // unflipped cull_rect vs flipped(empty) diff_rect
     // == cull_rect
     EXPECT_TRUE(cull_rect.Cutout(flip_lr(diff_rect)).has_value()) << label;
     EXPECT_EQ(cull_rect.Cutout(flip_lr(diff_rect)), cull_rect) << label;
     EXPECT_TRUE(cull_rect.Cutout(flip_tb(diff_rect)).has_value()) << label;
     EXPECT_EQ(cull_rect.Cutout(flip_tb(diff_rect)), cull_rect) << label;
     EXPECT_TRUE(cull_rect.Cutout(flip_lrtb(diff_rect)).has_value()) << label;
     EXPECT_EQ(cull_rect.Cutout(flip_lrtb(diff_rect)), cull_rect) << label;
  
     // flipped(empty) cull_rect vs flipped(empty) diff_rect
     // == empty
     EXPECT_FALSE(flip_lr(cull_rect).Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(diff_rect), IRect()) << label;
     EXPECT_FALSE(flip_tb(cull_rect).Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(diff_rect), IRect()) << label;
     EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(diff_rect), IRect()) << label;
  
     // flipped(empty) cull_rect vs unflipped diff_rect
     // == empty
     EXPECT_FALSE(flip_lr(cull_rect).Cutout(flip_lr(diff_rect)).has_value())
         << label;
     EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(flip_lr(diff_rect)), IRect())
         << label;
     EXPECT_FALSE(flip_tb(cull_rect).Cutout(flip_tb(diff_rect)).has_value())
         << label;
     EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(flip_tb(diff_rect)), IRect())
         << label;
     EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(flip_lrtb(diff_rect)).has_value())
         << label;
     EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(flip_lrtb(diff_rect)), IRect())
         << label;
   };
  
   auto non_reducing = [&cull_rect, &check_empty_flips](
                           const IRect& diff_rect, const std::string& label) {
     EXPECT_EQ(cull_rect.Cutout(diff_rect), cull_rect) << label;
     EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), cull_rect) << label;
     check_empty_flips(diff_rect, label);
   };
  
   auto reducing = [&cull_rect, &check_empty_flips](const IRect& diff_rect,
                                                    const IRect& result_rect,
                                                    const std::string& label) {
     EXPECT_TRUE(!result_rect.IsEmpty());
     EXPECT_EQ(cull_rect.Cutout(diff_rect), result_rect) << label;
     EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), result_rect) << label;
     check_empty_flips(diff_rect, label);
   };
  
   auto emptying = [&cull_rect, &check_empty_flips](const IRect& diff_rect,
                                                    const std::string& label) {
     EXPECT_FALSE(cull_rect.Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), IRect()) << label;
     check_empty_flips(diff_rect, label);
   };
  
   // Skim the corners and edge
   non_reducing(IRect::MakeLTRB(10, 10, 20, 20), "outside UL corner");
   non_reducing(IRect::MakeLTRB(20, 10, 40, 20), "Above");
   non_reducing(IRect::MakeLTRB(40, 10, 50, 20), "outside UR corner");
   non_reducing(IRect::MakeLTRB(40, 20, 50, 40), "Right");
   non_reducing(IRect::MakeLTRB(40, 40, 50, 50), "outside LR corner");
   non_reducing(IRect::MakeLTRB(20, 40, 40, 50), "Below");
   non_reducing(IRect::MakeLTRB(10, 40, 20, 50), "outside LR corner");
   non_reducing(IRect::MakeLTRB(10, 20, 20, 40), "Left");
  
   // Overlap corners
   non_reducing(IRect::MakeLTRB(15, 15, 25, 25), "covering UL corner");
   non_reducing(IRect::MakeLTRB(35, 15, 45, 25), "covering UR corner");
   non_reducing(IRect::MakeLTRB(35, 35, 45, 45), "covering LR corner");
   non_reducing(IRect::MakeLTRB(15, 35, 25, 45), "covering LL corner");
  
   // Overlap edges, but not across an entire side
   non_reducing(IRect::MakeLTRB(20, 15, 39, 25), "Top edge left-biased");
   non_reducing(IRect::MakeLTRB(21, 15, 40, 25), "Top edge, right biased");
   non_reducing(IRect::MakeLTRB(35, 20, 45, 39), "Right edge, top-biased");
   non_reducing(IRect::MakeLTRB(35, 21, 45, 40), "Right edge, bottom-biased");
   non_reducing(IRect::MakeLTRB(20, 35, 39, 45), "Bottom edge, left-biased");
   non_reducing(IRect::MakeLTRB(21, 35, 40, 45), "Bottom edge, right-biased");
   non_reducing(IRect::MakeLTRB(15, 20, 25, 39), "Left edge, top-biased");
   non_reducing(IRect::MakeLTRB(15, 21, 25, 40), "Left edge, bottom-biased");
  
   // Slice all the way through the middle
   non_reducing(IRect::MakeLTRB(25, 15, 35, 45), "Vertical interior slice");
   non_reducing(IRect::MakeLTRB(15, 25, 45, 35), "Horizontal interior slice");
  
   // Slice off each edge
   reducing(IRect::MakeLTRB(20, 15, 40, 25),  //
            IRect::MakeLTRB(20, 25, 40, 40),  //
            "Slice off top");
   reducing(IRect::MakeLTRB(35, 20, 45, 40),  //
            IRect::MakeLTRB(20, 20, 35, 40),  //
            "Slice off right");
   reducing(IRect::MakeLTRB(20, 35, 40, 45),  //
            IRect::MakeLTRB(20, 20, 40, 35),  //
            "Slice off bottom");
   reducing(IRect::MakeLTRB(15, 20, 25, 40),  //
            IRect::MakeLTRB(25, 20, 40, 40),  //
            "Slice off left");
  
   // cull rect contains diff rect
   non_reducing(IRect::MakeLTRB(21, 21, 39, 39), "Contained, non-covering");
  
   // cull rect equals diff rect
   emptying(cull_rect, "Perfectly covering");
  
   // diff rect contains cull rect
   emptying(IRect::MakeLTRB(15, 15, 45, 45), "Smothering");
 }

References impeller::TRect< T >::Cutout(), impeller::TRect< T >::CutoutOrEmpty(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [311/523]

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

Definition at line 59 of file rect_unittests.cc.

                                         {
   IRect rect = IRect();
  
   EXPECT_EQ(rect.GetLeft(), 0);
   EXPECT_EQ(rect.GetTop(), 0);
   EXPECT_EQ(rect.GetRight(), 0);
   EXPECT_EQ(rect.GetBottom(), 0);
   EXPECT_EQ(rect.GetX(), 0);
   EXPECT_EQ(rect.GetY(), 0);
   EXPECT_EQ(rect.GetWidth(), 0);
   EXPECT_EQ(rect.GetHeight(), 0);
   EXPECT_TRUE(rect.IsEmpty());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), and impeller::TRect< T >::IsEmpty().

◆ TEST() [312/523]

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

Definition at line 839 of file rect_unittests.cc.

                                            {
   IRect rect = IRect::MakeLTRB(50, 50, 100, 100);
  
   auto test = [&rect](int64_t l, int64_t t, int64_t r, int64_t b,
                       const std::string& label) {
     EXPECT_FALSE(rect.IntersectsWithRect(IRect::MakeLTRB(l, b, r, t)))
         << label << " with Top/Bottom swapped";
     EXPECT_FALSE(rect.IntersectsWithRect(IRect::MakeLTRB(r, b, l, t)))
         << label << " with Left/Right swapped";
     EXPECT_FALSE(rect.IntersectsWithRect(IRect::MakeLTRB(r, t, l, b)))
         << label << " with all sides swapped";
   };
  
   test(20, 20, 30, 30, "Above and Left");
   test(70, 20, 80, 30, "Above");
   test(120, 20, 130, 30, "Above and Right");
   test(120, 70, 130, 80, "Right");
   test(120, 120, 130, 130, "Below and Right");
   test(70, 120, 80, 130, "Below");
   test(20, 120, 30, 130, "Below and Left");
   test(20, 70, 30, 80, "Left");
  
   test(70, 70, 80, 80, "Inside");
  
   test(40, 70, 60, 80, "Straddling Left");
   test(70, 40, 80, 60, "Straddling Top");
   test(90, 70, 110, 80, "Straddling Right");
   test(70, 90, 80, 110, "Straddling Bottom");
 }

References impeller::saturated::b, impeller::TRect< T >::IntersectsWithRect(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [313/523]

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

Definition at line 29 of file rect_unittests.cc.

                                       {
   IRect rect;
  
   EXPECT_EQ(rect.GetLeft(), 0);
   EXPECT_EQ(rect.GetTop(), 0);
   EXPECT_EQ(rect.GetRight(), 0);
   EXPECT_EQ(rect.GetBottom(), 0);
   EXPECT_EQ(rect.GetX(), 0);
   EXPECT_EQ(rect.GetY(), 0);
   EXPECT_EQ(rect.GetWidth(), 0);
   EXPECT_EQ(rect.GetHeight(), 0);
   EXPECT_TRUE(rect.IsEmpty());
   // EXPECT_TRUE(rect.IsFinite());  // should fail to compile
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), and impeller::TRect< T >::IsEmpty().

◆ TEST() [314/523]

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

Definition at line 1283 of file rect_unittests.cc.

                             {
   auto rect = IRect::MakeLTRB(100, 100, 200, 200);
  
   // Expand(T amount)
   EXPECT_EQ(rect.Expand(10), IRect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(-10), IRect::MakeLTRB(110, 110, 190, 190));
  
   // Expand(amount, amount)
   EXPECT_EQ(rect.Expand(10, 10), IRect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(10, -10), IRect::MakeLTRB(90, 110, 210, 190));
   EXPECT_EQ(rect.Expand(-10, 10), IRect::MakeLTRB(110, 90, 190, 210));
   EXPECT_EQ(rect.Expand(-10, -10), IRect::MakeLTRB(110, 110, 190, 190));
  
   // Expand(amount, amount, amount, amount)
   EXPECT_EQ(rect.Expand(10, 20, 30, 40), IRect::MakeLTRB(90, 80, 230, 240));
   EXPECT_EQ(rect.Expand(-10, 20, 30, 40), IRect::MakeLTRB(110, 80, 230, 240));
   EXPECT_EQ(rect.Expand(10, -20, 30, 40), IRect::MakeLTRB(90, 120, 230, 240));
   EXPECT_EQ(rect.Expand(10, 20, -30, 40), IRect::MakeLTRB(90, 80, 170, 240));
   EXPECT_EQ(rect.Expand(10, 20, 30, -40), IRect::MakeLTRB(90, 80, 230, 160));
  
   // Expand(IPoint amount)
   EXPECT_EQ(rect.Expand(IPoint{10, 10}), IRect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(IPoint{10, -10}), IRect::MakeLTRB(90, 110, 210, 190));
   EXPECT_EQ(rect.Expand(IPoint{-10, 10}), IRect::MakeLTRB(110, 90, 190, 210));
   EXPECT_EQ(rect.Expand(IPoint{-10, -10}), IRect::MakeLTRB(110, 110, 190, 190));
  
   // Expand(ISize amount)
   EXPECT_EQ(rect.Expand(ISize{10, 10}), IRect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(ISize{10, -10}), IRect::MakeLTRB(90, 110, 210, 190));
   EXPECT_EQ(rect.Expand(ISize{-10, 10}), IRect::MakeLTRB(110, 90, 190, 210));
   EXPECT_EQ(rect.Expand(ISize{-10, -10}), IRect::MakeLTRB(110, 110, 190, 190));
 }

References impeller::TRect< T >::MakeLTRB().

◆ TEST() [315/523]

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

Definition at line 661 of file rect_unittests.cc.

                                {
   EXPECT_EQ(IRect(IRect::MakeXYWH(2, 3, 7, 15)),  //
             IRect::MakeXYWH(2, 3, 7, 15));
   EXPECT_EQ(IRect(IRect::MakeLTRB(2, 3, 7, 15)),  //
             IRect::MakeLTRB(2, 3, 7, 15));
 }

References impeller::TRect< T >::MakeLTRB(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [316/523]

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

Definition at line 1122 of file rect_unittests.cc.

                                              {
   {
     // Checks for expected matrix values
  
     auto r = IRect::MakeXYWH(100, 200, 200, 400);
  
     EXPECT_EQ(r.GetNormalizingTransform(),
               Matrix::MakeScale({0.005, 0.0025, 1.0}) *
                   Matrix::MakeTranslation({-100, -200}));
   }
  
   {
     // Checks for expected transform of points relative to the rect
  
     auto r = IRect::MakeLTRB(300, 500, 400, 700);
     auto m = r.GetNormalizingTransform();
  
     // The 4 corners of the rect => (0, 0) to (1, 1)
     EXPECT_EQ(m * Point(300, 500), Point(0, 0));
     EXPECT_EQ(m * Point(400, 500), Point(1, 0));
     EXPECT_EQ(m * Point(400, 700), Point(1, 1));
     EXPECT_EQ(m * Point(300, 700), Point(0, 1));
  
     // The center => (0.5, 0.5)
     EXPECT_EQ(m * Point(350, 600), Point(0.5, 0.5));
  
     // Outside the 4 corners => (-1, -1) to (2, 2)
     EXPECT_EQ(m * Point(200, 300), Point(-1, -1));
     EXPECT_EQ(m * Point(500, 300), Point(2, -1));
     EXPECT_EQ(m * Point(500, 900), Point(2, 2));
     EXPECT_EQ(m * Point(200, 900), Point(-1, 2));
   }
  
   {
     // Checks for behavior with empty rects
  
     auto zero = Matrix::MakeScale({0.0, 0.0, 1.0});
  
     // Empty for width and/or height == 0
     EXPECT_EQ(IRect::MakeXYWH(10, 10, 0, 10).GetNormalizingTransform(), zero);
     EXPECT_EQ(IRect::MakeXYWH(10, 10, 10, 0).GetNormalizingTransform(), zero);
     EXPECT_EQ(IRect::MakeXYWH(10, 10, 0, 0).GetNormalizingTransform(), zero);
  
     // Empty for width and/or height < 0
     EXPECT_EQ(IRect::MakeXYWH(10, 10, -1, 10).GetNormalizingTransform(), zero);
     EXPECT_EQ(IRect::MakeXYWH(10, 10, 10, -1).GetNormalizingTransform(), zero);
     EXPECT_EQ(IRect::MakeXYWH(10, 10, -1, -1).GetNormalizingTransform(), zero);
   }
 }

References impeller::TRect< T >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [317/523]

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

Definition at line 1800 of file rect_unittests.cc.

                                   {
   auto check_empty_flips = [](const IRect& a, const IRect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // b is allowed to be empty
  
     // unflipped a vs flipped (empty) b yields a
     EXPECT_FALSE(a.Intersection(flip_lr(b)).has_value()) << label;
     EXPECT_FALSE(a.Intersection(flip_tb(b)).has_value()) << label;
     EXPECT_FALSE(a.Intersection(flip_lrtb(b)).has_value()) << label;
  
     // flipped (empty) a vs unflipped b yields b
     EXPECT_FALSE(flip_lr(a).Intersection(b).has_value()) << label;
     EXPECT_FALSE(flip_tb(a).Intersection(b).has_value()) << label;
     EXPECT_FALSE(flip_lrtb(a).Intersection(b).has_value()) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_FALSE(flip_lr(a).Intersection(flip_lr(b)).has_value()) << label;
     EXPECT_FALSE(flip_tb(a).Intersection(flip_tb(b)).has_value()) << label;
     EXPECT_FALSE(flip_lrtb(a).Intersection(flip_lrtb(b)).has_value()) << label;
   };
  
   auto test_non_empty = [&check_empty_flips](const IRect& a, const IRect& b,
                                              const IRect& result) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_TRUE(a.Intersection(b).has_value()) << label;
     EXPECT_TRUE(b.Intersection(a).has_value()) << label;
     EXPECT_EQ(a.Intersection(b), result) << label;
     EXPECT_EQ(b.Intersection(a), result) << label;
     check_empty_flips(a, b, label);
   };
  
   auto test_empty = [&check_empty_flips](const IRect& a, const IRect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_FALSE(a.Intersection(b).has_value()) << label;
     EXPECT_FALSE(b.Intersection(a).has_value()) << label;
     check_empty_flips(a, b, label);
   };
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(0, 0, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(10, 10, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = IRect::MakeXYWH(0, 0, 100, 100);
     auto b = IRect::MakeXYWH(10, 10, 100, 100);
     auto expected = IRect::MakeXYWH(10, 10, 90, 90);
  
     test_non_empty(a, b, expected);
   }
  
   {
     auto a = IRect::MakeXYWH(0, 0, 100, 100);
     auto b = IRect::MakeXYWH(100, 100, 100, 100);
  
     test_empty(a, b);
   }
  
   {
     auto a = IRect::MakeMaximum();
     auto b = IRect::MakeXYWH(10, 10, 300, 300);
  
     test_non_empty(a, b, b);
   }
  
   {
     auto a = IRect::MakeMaximum();
     auto b = IRect::MakeMaximum();
  
     test_non_empty(a, b, IRect::MakeMaximum());
   }
 }

References impeller::saturated::b, flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::Intersection(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [318/523]

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

Definition at line 2065 of file rect_unittests.cc.

                                         {
   auto check_empty_flips = [](const IRect& a, const IRect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // b is allowed to be empty
  
     // unflipped a vs flipped (empty) b yields a
     EXPECT_FALSE(a.IntersectsWithRect(flip_lr(b))) << label;
     EXPECT_FALSE(a.IntersectsWithRect(flip_tb(b))) << label;
     EXPECT_FALSE(a.IntersectsWithRect(flip_lrtb(b))) << label;
  
     // flipped (empty) a vs unflipped b yields b
     EXPECT_FALSE(flip_lr(a).IntersectsWithRect(b)) << label;
     EXPECT_FALSE(flip_tb(a).IntersectsWithRect(b)) << label;
     EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(b)) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_FALSE(flip_lr(a).IntersectsWithRect(flip_lr(b))) << label;
     EXPECT_FALSE(flip_tb(a).IntersectsWithRect(flip_tb(b))) << label;
     EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(flip_lrtb(b))) << label;
   };
  
   auto test_non_empty = [&check_empty_flips](const IRect& a, const IRect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_TRUE(a.IntersectsWithRect(b)) << label;
     EXPECT_TRUE(b.IntersectsWithRect(a)) << label;
     check_empty_flips(a, b, label);
   };
  
   auto test_empty = [&check_empty_flips](const IRect& a, const IRect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_FALSE(a.IntersectsWithRect(b)) << label;
     EXPECT_FALSE(b.IntersectsWithRect(a)) << label;
     check_empty_flips(a, b, label);
   };
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(0, 0, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(10, 10, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = IRect::MakeXYWH(0, 0, 100, 100);
     auto b = IRect::MakeXYWH(10, 10, 100, 100);
  
     test_non_empty(a, b);
   }
  
   {
     auto a = IRect::MakeXYWH(0, 0, 100, 100);
     auto b = IRect::MakeXYWH(100, 100, 100, 100);
  
     test_empty(a, b);
   }
  
   {
     auto a = IRect::MakeMaximum();
     auto b = IRect::MakeXYWH(10, 10, 100, 100);
  
     test_non_empty(a, b);
   }
  
   {
     auto a = IRect::MakeMaximum();
     auto b = IRect::MakeMaximum();
  
     test_non_empty(a, b);
   }
 }

References impeller::saturated::b, flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IntersectsWithRect(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [319/523]

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

Definition at line 638 of file rect_unittests.cc.

                                  {
   IRect rect = IRect::MakeMaximum();
   auto min = std::numeric_limits<int64_t>::min();
   auto max = std::numeric_limits<int64_t>::max();
  
   EXPECT_EQ(rect.GetLeft(), min);
   EXPECT_EQ(rect.GetTop(), min);
   EXPECT_EQ(rect.GetRight(), max);
   EXPECT_EQ(rect.GetBottom(), max);
   EXPECT_EQ(rect.GetX(), min);
   EXPECT_EQ(rect.GetY(), min);
   EXPECT_EQ(rect.GetWidth(), max);
   EXPECT_EQ(rect.GetHeight(), max);
   EXPECT_FALSE(rect.IsEmpty());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeMaximum().

◆ TEST() [320/523]

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

Definition at line 728 of file rect_unittests.cc.

                                            {
   {
     IRect r = IRect::MakeOriginSize({10, 20}, {50, 40});
     EXPECT_EQ(r.GetOrigin(), IPoint(10, 20));
     EXPECT_EQ(r.GetSize(), ISize(50, 40));
     EXPECT_EQ(r.GetX(), 10);
     EXPECT_EQ(r.GetY(), 20);
     EXPECT_EQ(r.GetWidth(), 50);
     EXPECT_EQ(r.GetHeight(), 40);
     auto expected_array = std::array<int64_t, 4>{10, 20, 50, 40};
     EXPECT_EQ(r.GetXYWH(), expected_array);
   }
  
   {
     IRect r = IRect::MakeLTRB(10, 20, 50, 40);
     EXPECT_EQ(r.GetOrigin(), IPoint(10, 20));
     EXPECT_EQ(r.GetSize(), ISize(40, 20));
     EXPECT_EQ(r.GetX(), 10);
     EXPECT_EQ(r.GetY(), 20);
     EXPECT_EQ(r.GetWidth(), 40);
     EXPECT_EQ(r.GetHeight(), 20);
     auto expected_array = std::array<int64_t, 4>{10, 20, 40, 20};
     EXPECT_EQ(r.GetXYWH(), expected_array);
   }
 }

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetXYWH(), impeller::TRect< T >::GetY(), impeller::TRect< T >::MakeLTRB(), and impeller::TRect< T >::MakeOriginSize().

◆ TEST() [321/523]

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

Definition at line 523 of file rect_unittests.cc.

                                   {
   auto min = std::numeric_limits<int64_t>::min();
   auto max = std::numeric_limits<int64_t>::max();
  
   // 4 cases
   //   negative l, r near max takes width past max
   //   positive l, r near min takes width below min
   //   negative t, b near max takes width past max
   //   positive t, b near min takes width below min
  
   {
     IRect rect = IRect::MakeLTRB(-10, 10, max - 5, 26);
  
     EXPECT_EQ(rect.GetLeft(), -10);
     EXPECT_EQ(rect.GetTop(), 10);
     EXPECT_EQ(rect.GetRight(), max - 5);
     EXPECT_EQ(rect.GetBottom(), 26);
     EXPECT_EQ(rect.GetX(), -10);
     EXPECT_EQ(rect.GetY(), 10);
     EXPECT_EQ(rect.GetWidth(), max);
     EXPECT_EQ(rect.GetHeight(), 16);
     EXPECT_FALSE(rect.IsEmpty());
   }
  
   {
     IRect rect = IRect::MakeLTRB(10, 10, min + 5, 26);
  
     EXPECT_EQ(rect.GetLeft(), 10);
     EXPECT_EQ(rect.GetTop(), 10);
     EXPECT_EQ(rect.GetRight(), min + 5);
     EXPECT_EQ(rect.GetBottom(), 26);
     EXPECT_EQ(rect.GetX(), 10);
     EXPECT_EQ(rect.GetY(), 10);
     EXPECT_EQ(rect.GetWidth(), min);
     EXPECT_EQ(rect.GetHeight(), 16);
     EXPECT_TRUE(rect.IsEmpty());
   }
  
   {
     IRect rect = IRect::MakeLTRB(5, -10, 15, max - 5);
  
     EXPECT_EQ(rect.GetLeft(), 5);
     EXPECT_EQ(rect.GetTop(), -10);
     EXPECT_EQ(rect.GetRight(), 15);
     EXPECT_EQ(rect.GetBottom(), max - 5);
     EXPECT_EQ(rect.GetX(), 5);
     EXPECT_EQ(rect.GetY(), -10);
     EXPECT_EQ(rect.GetWidth(), 10);
     EXPECT_EQ(rect.GetHeight(), max);
     EXPECT_FALSE(rect.IsEmpty());
   }
  
   {
     IRect rect = IRect::MakeLTRB(5, 10, 15, min + 5);
  
     EXPECT_EQ(rect.GetLeft(), 5);
     EXPECT_EQ(rect.GetTop(), 10);
     EXPECT_EQ(rect.GetRight(), 15);
     EXPECT_EQ(rect.GetBottom(), min + 5);
     EXPECT_EQ(rect.GetX(), 5);
     EXPECT_EQ(rect.GetY(), 10);
     EXPECT_EQ(rect.GetWidth(), 10);
     EXPECT_EQ(rect.GetHeight(), min);
     EXPECT_TRUE(rect.IsEmpty());
   }
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [322/523]

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

Definition at line 317 of file rect_unittests.cc.

                                   {
   auto min = std::numeric_limits<int64_t>::min();
   auto max = std::numeric_limits<int64_t>::max();
  
   // 4 cases
   //   x near max, positive w takes it past max
   //   x near min, negative w takes it below min
   //   y near max, positive h takes it past max
   //   y near min, negative h takes it below min
  
   {
     IRect rect = IRect::MakeXYWH(max - 5, 10, 10, 16);
  
     EXPECT_EQ(rect.GetLeft(), max - 5);
     EXPECT_EQ(rect.GetTop(), 10);
     EXPECT_EQ(rect.GetRight(), max);
     EXPECT_EQ(rect.GetBottom(), 26);
     EXPECT_EQ(rect.GetX(), max - 5);
     EXPECT_EQ(rect.GetY(), 10);
     EXPECT_EQ(rect.GetWidth(), 5);
     EXPECT_EQ(rect.GetHeight(), 16);
     EXPECT_FALSE(rect.IsEmpty());
   }
  
   {
     IRect rect = IRect::MakeXYWH(min + 5, 10, -10, 16);
  
     EXPECT_EQ(rect.GetLeft(), min + 5);
     EXPECT_EQ(rect.GetTop(), 10);
     EXPECT_EQ(rect.GetRight(), min);
     EXPECT_EQ(rect.GetBottom(), 26);
     EXPECT_EQ(rect.GetX(), min + 5);
     EXPECT_EQ(rect.GetY(), 10);
     EXPECT_EQ(rect.GetWidth(), -5);
     EXPECT_EQ(rect.GetHeight(), 16);
     EXPECT_TRUE(rect.IsEmpty());
   }
  
   {
     IRect rect = IRect::MakeXYWH(5, max - 10, 10, 16);
  
     EXPECT_EQ(rect.GetLeft(), 5);
     EXPECT_EQ(rect.GetTop(), max - 10);
     EXPECT_EQ(rect.GetRight(), 15);
     EXPECT_EQ(rect.GetBottom(), max);
     EXPECT_EQ(rect.GetX(), 5);
     EXPECT_EQ(rect.GetY(), max - 10);
     EXPECT_EQ(rect.GetWidth(), 10);
     EXPECT_EQ(rect.GetHeight(), 10);
     EXPECT_FALSE(rect.IsEmpty());
   }
  
   {
     IRect rect = IRect::MakeXYWH(5, min + 10, 10, -16);
  
     EXPECT_EQ(rect.GetLeft(), 5);
     EXPECT_EQ(rect.GetTop(), min + 10);
     EXPECT_EQ(rect.GetRight(), 15);
     EXPECT_EQ(rect.GetBottom(), min);
     EXPECT_EQ(rect.GetX(), 5);
     EXPECT_EQ(rect.GetY(), min + 10);
     EXPECT_EQ(rect.GetWidth(), 10);
     EXPECT_EQ(rect.GetHeight(), -10);
     EXPECT_TRUE(rect.IsEmpty());
   }
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [323/523]

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

Definition at line 3098 of file rect_unittests.cc.

                            {
   {
     auto r = Rect::MakeLTRB(-100, -200, 300, 400);
     auto ir = IRect::MakeLTRB(-100, -200, 300, 400);
     EXPECT_EQ(IRect::Round(r), ir);
   }
   {
     auto r = Rect::MakeLTRB(-100.4, -200.4, 300.4, 400.4);
     auto ir = IRect::MakeLTRB(-100, -200, 300, 400);
     EXPECT_EQ(IRect::Round(r), ir);
   }
   {
     auto r = Rect::MakeLTRB(-100.5, -200.5, 300.5, 400.5);
     auto ir = IRect::MakeLTRB(-101, -201, 301, 401);
     EXPECT_EQ(IRect::Round(r), ir);
   }
 }

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

◆ TEST() [324/523]

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

Definition at line 3070 of file rect_unittests.cc.

                               {
   {
     auto r = Rect::MakeLTRB(-100, -200, 300, 400);
     auto ir = IRect::MakeLTRB(-100, -200, 300, 400);
     EXPECT_EQ(IRect::RoundOut(r), ir);
   }
   {
     auto r = Rect::MakeLTRB(-100.1, -200.1, 300.1, 400.1);
     auto ir = IRect::MakeLTRB(-101, -201, 301, 401);
     EXPECT_EQ(IRect::RoundOut(r), ir);
   }
 }

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

◆ TEST() [325/523]

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

Definition at line 974 of file rect_unittests.cc.

                            {
   auto test1 = [](IRect rect, int64_t scale) {
     IRect expected = IRect::MakeXYWH(rect.GetX() * scale,      //
                                      rect.GetY() * scale,      //
                                      rect.GetWidth() * scale,  //
                                      rect.GetHeight() * scale);
  
     EXPECT_EQ(rect.Scale(scale), expected)  //
         << rect << " * " << scale;
     EXPECT_EQ(rect.Scale(scale, scale), expected)  //
         << rect << " * " << scale;
     EXPECT_EQ(rect.Scale(IPoint(scale, scale)), expected)  //
         << rect << " * " << scale;
     EXPECT_EQ(rect.Scale(ISize(scale, scale)), expected)  //
         << rect << " * " << scale;
   };
  
   auto test2 = [&test1](IRect rect, int64_t scale_x, int64_t scale_y) {
     IRect expected = IRect::MakeXYWH(rect.GetX() * scale_x,      //
                                      rect.GetY() * scale_y,      //
                                      rect.GetWidth() * scale_x,  //
                                      rect.GetHeight() * scale_y);
  
     EXPECT_EQ(rect.Scale(scale_x, scale_y), expected)  //
         << rect << " * " << scale_x << ", " << scale_y;
     EXPECT_EQ(rect.Scale(IPoint(scale_x, scale_y)), expected)  //
         << rect << " * " << scale_x << ", " << scale_y;
     EXPECT_EQ(rect.Scale(ISize(scale_x, scale_y)), expected)  //
         << rect << " * " << scale_x << ", " << scale_y;
  
     test1(rect, scale_x);
     test1(rect, scale_y);
   };
  
   test2(IRect::MakeLTRB(10, 15, 100, 150), 2, 3);
   test2(IRect::MakeLTRB(10, 15, 100, 150), 3, 2);
   test2(IRect::MakeLTRB(10, 15, -100, 150), 2, 3);
   test2(IRect::MakeLTRB(10, 15, 100, -150), 2, 3);
   test2(IRect::MakeLTRB(10, 15, 100, 150), -2, 3);
   test2(IRect::MakeLTRB(10, 15, 100, 150), 2, -3);
 }

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< T >::Scale().

◆ TEST() [326/523]

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

Definition at line 89 of file rect_unittests.cc.

                                 {
   IRect rect = IRect::MakeLTRB(5, 10, 20, 25);
  
   EXPECT_EQ(rect.GetLeft(), 5);
   EXPECT_EQ(rect.GetTop(), 10);
   EXPECT_EQ(rect.GetRight(), 20);
   EXPECT_EQ(rect.GetBottom(), 25);
   EXPECT_EQ(rect.GetX(), 5);
   EXPECT_EQ(rect.GetY(), 10);
   EXPECT_EQ(rect.GetWidth(), 15);
   EXPECT_EQ(rect.GetHeight(), 15);
   EXPECT_FALSE(rect.IsEmpty());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [327/523]

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

Definition at line 149 of file rect_unittests.cc.

                               {
   // Using fractional-power-of-2 friendly values for equality tests
   IRect rect = IRect::MakeWH(15, 25);
  
   EXPECT_EQ(rect.GetLeft(), 0);
   EXPECT_EQ(rect.GetTop(), 0);
   EXPECT_EQ(rect.GetRight(), 15);
   EXPECT_EQ(rect.GetBottom(), 25);
   EXPECT_EQ(rect.GetX(), 0);
   EXPECT_EQ(rect.GetY(), 0);
   EXPECT_EQ(rect.GetWidth(), 15);
   EXPECT_EQ(rect.GetHeight(), 25);
   EXPECT_FALSE(rect.IsEmpty());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeWH().

◆ TEST() [328/523]

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

Definition at line 119 of file rect_unittests.cc.

                                 {
   IRect rect = IRect::MakeXYWH(5, 10, 15, 16);
  
   EXPECT_EQ(rect.GetLeft(), 5);
   EXPECT_EQ(rect.GetTop(), 10);
   EXPECT_EQ(rect.GetRight(), 20);
   EXPECT_EQ(rect.GetBottom(), 26);
   EXPECT_EQ(rect.GetX(), 5);
   EXPECT_EQ(rect.GetY(), 10);
   EXPECT_EQ(rect.GetWidth(), 15);
   EXPECT_EQ(rect.GetHeight(), 16);
   EXPECT_FALSE(rect.IsEmpty());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [329/523]

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

Definition at line 1497 of file rect_unittests.cc.

                            {
   auto check_empty_flips = [](const IRect& a, const IRect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // b is allowed to be empty
  
     // unflipped a vs flipped (empty) b yields a
     EXPECT_EQ(a.Union(flip_lr(b)), a) << label;
     EXPECT_EQ(a.Union(flip_tb(b)), a) << label;
     EXPECT_EQ(a.Union(flip_lrtb(b)), a) << label;
  
     // flipped (empty) a vs unflipped b yields b
     EXPECT_EQ(flip_lr(a).Union(b), b) << label;
     EXPECT_EQ(flip_tb(a).Union(b), b) << label;
     EXPECT_EQ(flip_lrtb(a).Union(b), b) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_TRUE(flip_lr(a).Union(flip_lr(b)).IsEmpty()) << label;
     EXPECT_TRUE(flip_tb(a).Union(flip_tb(b)).IsEmpty()) << label;
     EXPECT_TRUE(flip_lrtb(a).Union(flip_lrtb(b)).IsEmpty()) << label;
   };
  
   auto test = [&check_empty_flips](const IRect& a, const IRect& b,
                                    const IRect& result) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_EQ(a.Union(b), result) << label;
     EXPECT_EQ(b.Union(a), result) << label;
     check_empty_flips(a, b, label);
   };
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(0, 0, 0, 0);
     auto expected = IRect::MakeXYWH(100, 100, 100, 100);
     test(a, b, expected);
   }
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(0, 0, 1, 1);
     auto expected = IRect::MakeXYWH(0, 0, 200, 200);
     test(a, b, expected);
   }
  
   {
     auto a = IRect::MakeXYWH(100, 100, 100, 100);
     auto b = IRect::MakeXYWH(10, 10, 1, 1);
     auto expected = IRect::MakeXYWH(10, 10, 190, 190);
     test(a, b, expected);
   }
  
   {
     auto a = IRect::MakeXYWH(0, 0, 100, 100);
     auto b = IRect::MakeXYWH(10, 10, 100, 100);
     auto expected = IRect::MakeXYWH(0, 0, 110, 110);
     test(a, b, expected);
   }
  
   {
     auto a = IRect::MakeXYWH(0, 0, 100, 100);
     auto b = IRect::MakeXYWH(100, 100, 100, 100);
     auto expected = IRect::MakeXYWH(0, 0, 200, 200);
     test(a, b, expected);
   }
 }

References impeller::saturated::b, flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< T >::Union().

◆ TEST() [330/523]

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

Definition at line 1196 of file rect_unittests.cc.

                                  {
   // Non-empty
   EXPECT_FALSE(IRect::MakeXYWH(1, 2, 10, 7).IsEmpty());
  
   // Empty both width and height both 0 or negative, in all combinations
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, 0, 0).IsEmpty());
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, -1, -1).IsEmpty());
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, -1, 0).IsEmpty());
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, 0, -1).IsEmpty());
  
   // Empty for 0 or negative width or height (but not both at the same time)
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, 10, 0).IsEmpty());
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, 10, -1).IsEmpty());
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, 0, 7).IsEmpty());
   EXPECT_TRUE(IRect::MakeXYWH(1, 2, -1, 7).IsEmpty());
 }

References impeller::TRect< T >::MakeXYWH().

◆ TEST() [331/523]

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

Definition at line 1227 of file rect_unittests.cc.

                          {
   EXPECT_TRUE(Rect::MakeXYWH(10, 30, 20, 20).IsSquare());
   EXPECT_FALSE(Rect::MakeXYWH(10, 30, 20, 19).IsSquare());
   EXPECT_FALSE(Rect::MakeXYWH(10, 30, 19, 20).IsSquare());
   EXPECT_TRUE(Rect::MakeMaximum().IsSquare());
  
   EXPECT_TRUE(IRect::MakeXYWH(10, 30, 20, 20).IsSquare());
   EXPECT_FALSE(IRect::MakeXYWH(10, 30, 20, 19).IsSquare());
   EXPECT_FALSE(IRect::MakeXYWH(10, 30, 19, 20).IsSquare());
   EXPECT_TRUE(IRect::MakeMaximum().IsSquare());
 }

References impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< T >::MakeMaximum(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [332/523]

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

Definition at line 1213 of file rect_unittests.cc.

                                     {
   Quad quad = {
       Point(10, 10),
       Point(20, 10),
       Point(10, 20),
       Point(20, 20),
   };
   std::optional<Rect> bounds = Rect::MakePointBounds(quad);
   EXPECT_TRUE(bounds.has_value());
   if (bounds.has_value()) {
     EXPECT_TRUE(RectNear(bounds.value(), Rect::MakeLTRB(10, 10, 20, 20)));
   }
 }

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

◆ TEST() [333/523]

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

Definition at line 1895 of file rect_unittests.cc.

                                      {
   auto a = IRect::MakeLTRB(0, 0, 110, 110);
   auto b = IRect::MakeLTRB(100, 100, 200, 200);
   auto c = IRect::MakeLTRB(100, 0, 200, 110);
  
   // NullOpt, NullOpt
   EXPECT_FALSE(IRect::Intersection(std::nullopt, std::nullopt).has_value());
   EXPECT_EQ(IRect::Intersection(std::nullopt, std::nullopt), std::nullopt);
  
   auto test1 = [](const IRect& r) {
     // Rect, NullOpt
     EXPECT_TRUE(IRect::Intersection(r, std::nullopt).has_value());
     EXPECT_EQ(IRect::Intersection(r, std::nullopt).value(), r);
  
     // OptRect, NullOpt
     EXPECT_TRUE(
         IRect::Intersection(std::optional(r), std::nullopt).has_value());
     EXPECT_EQ(IRect::Intersection(std::optional(r), std::nullopt).value(), r);
  
     // NullOpt, Rect
     EXPECT_TRUE(IRect::Intersection(std::nullopt, r).has_value());
     EXPECT_EQ(IRect::Intersection(std::nullopt, r).value(), r);
  
     // NullOpt, OptRect
     EXPECT_TRUE(
         IRect::Intersection(std::nullopt, std::optional(r)).has_value());
     EXPECT_EQ(IRect::Intersection(std::nullopt, std::optional(r)).value(), r);
   };
  
   test1(a);
   test1(b);
   test1(c);
  
   auto test2 = [](const IRect& a, const IRect& b, const IRect& i) {
     ASSERT_EQ(a.Intersection(b), i);
  
     // Rect, OptRect
     EXPECT_TRUE(IRect::Intersection(a, std::optional(b)).has_value());
     EXPECT_EQ(IRect::Intersection(a, std::optional(b)).value(), i);
  
     // OptRect, Rect
     EXPECT_TRUE(IRect::Intersection(std::optional(a), b).has_value());
     EXPECT_EQ(IRect::Intersection(std::optional(a), b).value(), i);
  
     // OptRect, OptRect
     EXPECT_TRUE(
         IRect::Intersection(std::optional(a), std::optional(b)).has_value());
     EXPECT_EQ(IRect::Intersection(std::optional(a), std::optional(b)).value(),
               i);
   };
  
   test2(a, b, IRect::MakeLTRB(100, 100, 110, 110));
   test2(a, c, IRect::MakeLTRB(100, 0, 110, 110));
   test2(b, c, IRect::MakeLTRB(100, 100, 200, 110));
 }

References impeller::saturated::b, impeller::TRect< T >::Intersection(), impeller::TRect< T >::MakeLTRB(), and value.

◆ TEST() [334/523]

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

Definition at line 1569 of file rect_unittests.cc.

                               {
   auto a = IRect::MakeLTRB(0, 0, 100, 100);
   auto b = IRect::MakeLTRB(100, 100, 200, 200);
   auto c = IRect::MakeLTRB(100, 0, 200, 100);
  
   // NullOpt, NullOpt
   EXPECT_FALSE(IRect::Union(std::nullopt, std::nullopt).has_value());
   EXPECT_EQ(IRect::Union(std::nullopt, std::nullopt), std::nullopt);
  
   auto test1 = [](const IRect& r) {
     // Rect, NullOpt
     EXPECT_EQ(IRect::Union(r, std::nullopt), r);
  
     // OptRect, NullOpt
     EXPECT_TRUE(IRect::Union(std::optional(r), std::nullopt).has_value());
     EXPECT_EQ(IRect::Union(std::optional(r), std::nullopt).value(), r);
  
     // NullOpt, Rect
     EXPECT_EQ(IRect::Union(std::nullopt, r), r);
  
     // NullOpt, OptRect
     EXPECT_TRUE(IRect::Union(std::nullopt, std::optional(r)).has_value());
     EXPECT_EQ(IRect::Union(std::nullopt, std::optional(r)).value(), r);
   };
  
   test1(a);
   test1(b);
   test1(c);
  
   auto test2 = [](const IRect& a, const IRect& b, const IRect& u) {
     ASSERT_EQ(a.Union(b), u);
  
     // Rect, OptRect
     EXPECT_EQ(IRect::Union(a, std::optional(b)), u);
  
     // OptRect, Rect
     EXPECT_EQ(IRect::Union(std::optional(a), b), u);
  
     // OptRect, OptRect
     EXPECT_TRUE(IRect::Union(std::optional(a), std::optional(b)).has_value());
     EXPECT_EQ(IRect::Union(std::optional(a), std::optional(b)).value(), u);
   };
  
   test2(a, b, IRect::MakeLTRB(0, 0, 200, 200));
   test2(a, c, IRect::MakeLTRB(0, 0, 200, 100));
   test2(b, c, IRect::MakeLTRB(100, 0, 200, 200));
 }

References impeller::saturated::b, impeller::TRect< T >::MakeLTRB(), impeller::TRect< T >::Union(), and value.

◆ TEST() [335/523]

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

Definition at line 1746 of file rect_unittests.cc.

                                     {
   auto a = Rect::MakeLTRB(0, 0, 110, 110);
   auto b = Rect::MakeLTRB(100, 100, 200, 200);
   auto c = Rect::MakeLTRB(100, 0, 200, 110);
  
   // NullOpt, NullOpt
   EXPECT_FALSE(Rect::Intersection(std::nullopt, std::nullopt).has_value());
   EXPECT_EQ(Rect::Intersection(std::nullopt, std::nullopt), std::nullopt);
  
   auto test1 = [](const Rect& r) {
     // Rect, NullOpt
     EXPECT_TRUE(Rect::Intersection(r, std::nullopt).has_value());
     EXPECT_EQ(Rect::Intersection(r, std::nullopt).value(), r);
  
     // OptRect, NullOpt
     EXPECT_TRUE(Rect::Intersection(std::optional(r), std::nullopt).has_value());
     EXPECT_EQ(Rect::Intersection(std::optional(r), std::nullopt).value(), r);
  
     // NullOpt, Rect
     EXPECT_TRUE(Rect::Intersection(std::nullopt, r).has_value());
     EXPECT_EQ(Rect::Intersection(std::nullopt, r).value(), r);
  
     // NullOpt, OptRect
     EXPECT_TRUE(Rect::Intersection(std::nullopt, std::optional(r)).has_value());
     EXPECT_EQ(Rect::Intersection(std::nullopt, std::optional(r)).value(), r);
   };
  
   test1(a);
   test1(b);
   test1(c);
  
   auto test2 = [](const Rect& a, const Rect& b, const Rect& i) {
     ASSERT_EQ(a.Intersection(b), i);
  
     // Rect, OptRect
     EXPECT_TRUE(Rect::Intersection(a, std::optional(b)).has_value());
     EXPECT_EQ(Rect::Intersection(a, std::optional(b)).value(), i);
  
     // OptRect, Rect
     EXPECT_TRUE(Rect::Intersection(std::optional(a), b).has_value());
     EXPECT_EQ(Rect::Intersection(std::optional(a), b).value(), i);
  
     // OptRect, OptRect
     EXPECT_TRUE(
         Rect::Intersection(std::optional(a), std::optional(b)).has_value());
     EXPECT_EQ(Rect::Intersection(std::optional(a), std::optional(b)).value(),
               i);
   };
  
   test2(a, b, Rect::MakeLTRB(100, 100, 110, 110));
   test2(a, c, Rect::MakeLTRB(100, 0, 110, 110));
   test2(b, c, Rect::MakeLTRB(100, 100, 200, 110));
 }

References impeller::saturated::b, impeller::TRect< T >::Intersection(), impeller::TRect< Scalar >::Intersection(), impeller::TRect< Scalar >::MakeLTRB(), and value.

◆ TEST() [336/523]

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

Definition at line 1449 of file rect_unittests.cc.

                              {
   auto a = Rect::MakeLTRB(0, 0, 100, 100);
   auto b = Rect::MakeLTRB(100, 100, 200, 200);
   auto c = Rect::MakeLTRB(100, 0, 200, 100);
  
   // NullOpt, NullOpt
   EXPECT_FALSE(Rect::Union(std::nullopt, std::nullopt).has_value());
   EXPECT_EQ(Rect::Union(std::nullopt, std::nullopt), std::nullopt);
  
   auto test1 = [](const Rect& r) {
     // Rect, NullOpt
     EXPECT_EQ(Rect::Union(r, std::nullopt), r);
  
     // OptRect, NullOpt
     EXPECT_TRUE(Rect::Union(std::optional(r), std::nullopt).has_value());
     EXPECT_EQ(Rect::Union(std::optional(r), std::nullopt).value(), r);
  
     // NullOpt, Rect
     EXPECT_EQ(Rect::Union(std::nullopt, r), r);
  
     // NullOpt, OptRect
     EXPECT_TRUE(Rect::Union(std::nullopt, std::optional(r)).has_value());
     EXPECT_EQ(Rect::Union(std::nullopt, std::optional(r)).value(), r);
   };
  
   test1(a);
   test1(b);
   test1(c);
  
   auto test2 = [](const Rect& a, const Rect& b, const Rect& u) {
     ASSERT_EQ(a.Union(b), u);
  
     // Rect, OptRect
     EXPECT_EQ(Rect::Union(a, std::optional(b)), u);
  
     // OptRect, Rect
     EXPECT_EQ(Rect::Union(std::optional(a), b), u);
  
     // OptRect, OptRect
     EXPECT_TRUE(Rect::Union(std::optional(a), std::optional(b)).has_value());
     EXPECT_EQ(Rect::Union(std::optional(a), std::optional(b)).value(), u);
   };
  
   test2(a, b, Rect::MakeLTRB(0, 0, 200, 200));
   test2(a, c, Rect::MakeLTRB(0, 0, 200, 100));
   test2(b, c, Rect::MakeLTRB(100, 0, 200, 200));
 }

References impeller::saturated::b, impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< T >::Union(), impeller::TRect< Scalar >::Union(), and value.

◆ TEST() [337/523]

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

Definition at line 1016 of file rect_unittests.cc.

                          {
   EXPECT_EQ(Rect::MakeXYWH(0, 0, 100, 200).Area(), 20000);
   EXPECT_EQ(Rect::MakeXYWH(10, 20, 100, 200).Area(), 20000);
   EXPECT_EQ(Rect::MakeXYWH(0, 0, 200, 100).Area(), 20000);
   EXPECT_EQ(Rect::MakeXYWH(10, 20, 200, 100).Area(), 20000);
   EXPECT_EQ(Rect::MakeXYWH(0, 0, 100, 100).Area(), 10000);
   EXPECT_EQ(Rect::MakeXYWH(10, 20, 100, 100).Area(), 10000);
 }

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [338/523]

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

Definition at line 2311 of file rect_unittests.cc.

                                            {
   auto check_nans = [](const Rect& rect, const Point& point,
                        const std::string& label) {
     ASSERT_TRUE(rect.IsFinite()) << label;
     ASSERT_TRUE(point.IsFinite()) << label;
  
     for (int i = 1; i < 16; i++) {
       EXPECT_FALSE(swap_nan(rect, i).ContainsInclusive(point))
           << label << ", index = " << i;
       for (int j = 1; j < 4; j++) {
         EXPECT_FALSE(swap_nan(rect, i).ContainsInclusive(swap_nan(point, j)))
             << label << ", indices = " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [](const Rect& rect, const Point& point,
                               const std::string& label) {
     ASSERT_FALSE(rect.IsEmpty());
  
     EXPECT_FALSE(flip_lr(rect).ContainsInclusive(point)) << label;
     EXPECT_FALSE(flip_tb(rect).ContainsInclusive(point)) << label;
     EXPECT_FALSE(flip_lrtb(rect).ContainsInclusive(point)) << label;
   };
  
   auto test_inside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                        const Point& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_TRUE(rect.ContainsInclusive(point)) << label;
     check_empty_flips(rect, point, label);
     check_nans(rect, point, label);
   };
  
   auto test_outside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                         const Point& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_FALSE(rect.ContainsInclusive(point)) << label;
     check_empty_flips(rect, point, label);
     check_nans(rect, point, label);
   };
  
   {
     // Origin is inclusive
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(100, 100);
  
     test_inside(r, p);
   }
   {
     // Size is inclusive
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(200, 200);
  
     test_inside(r, p);
   }
   {
     // Size + epsilon is exclusive
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(200 + kEhCloseEnough, 200 + kEhCloseEnough);
  
     test_outside(r, p);
   }
   {
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(99, 99);
  
     test_outside(r, p);
   }
   {
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(199, 199);
  
     test_inside(r, p);
   }
  
   {
     auto r = Rect::MakeMaximum();
     auto p = Point(199, 199);
  
     test_inside(r, p);
   }
 }

References impeller::TRect< T >::ContainsInclusive(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::kEhCloseEnough, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [339/523]

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

Definition at line 2156 of file rect_unittests.cc.

                                   {
   auto check_nans = [](const Rect& rect, const Point& point,
                        const std::string& label) {
     ASSERT_TRUE(rect.IsFinite()) << label;
     ASSERT_TRUE(point.IsFinite()) << label;
  
     for (int i = 1; i < 16; i++) {
       EXPECT_FALSE(swap_nan(rect, i).Contains(point))
           << label << ", index = " << i;
       for (int j = 1; j < 4; j++) {
         EXPECT_FALSE(swap_nan(rect, i).Contains(swap_nan(point, j)))
             << label << ", indices = " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [](const Rect& rect, const Point& point,
                               const std::string& label) {
     ASSERT_FALSE(rect.IsEmpty());
  
     EXPECT_FALSE(flip_lr(rect).Contains(point)) << label;
     EXPECT_FALSE(flip_tb(rect).Contains(point)) << label;
     EXPECT_FALSE(flip_lrtb(rect).Contains(point)) << label;
   };
  
   auto test_inside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                        const Point& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_TRUE(rect.Contains(point)) << label;
     check_empty_flips(rect, point, label);
     check_nans(rect, point, label);
   };
  
   auto test_outside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                         const Point& point) {
     ASSERT_FALSE(rect.IsEmpty()) << rect;
  
     std::stringstream stream;
     stream << rect << " contains " << point;
     auto label = stream.str();
  
     EXPECT_FALSE(rect.Contains(point)) << label;
     check_empty_flips(rect, point, label);
     check_nans(rect, point, label);
   };
  
   {
     // Origin is inclusive
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(100, 100);
  
     test_inside(r, p);
   }
   {
     // Size is exclusive
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(200, 200);
  
     test_outside(r, p);
   }
   {
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(99, 99);
  
     test_outside(r, p);
   }
   {
     auto r = Rect::MakeXYWH(100, 100, 100, 100);
     auto p = Point(199, 199);
  
     test_inside(r, p);
   }
  
   {
     auto r = Rect::MakeMaximum();
     auto p = Point(199, 199);
  
     test_inside(r, p);
   }
 }

References impeller::TRect< T >::Contains(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [340/523]

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

Definition at line 2480 of file rect_unittests.cc.

                                  {
   auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
     ASSERT_TRUE(a.IsFinite()) << label;
     ASSERT_TRUE(b.IsFinite()) << label;
     ASSERT_FALSE(a.IsEmpty());
  
     for (int i = 1; i < 16; i++) {
       // NaN in a produces false
       EXPECT_FALSE(swap_nan(a, i).Contains(b)) << label << ", index = " << i;
       // NaN in b produces false
       EXPECT_TRUE(a.Contains(swap_nan(b, i))) << label << ", index = " << i;
       // NaN in both is false
       for (int j = 1; j < 16; j++) {
         EXPECT_FALSE(swap_nan(a, i).Contains(swap_nan(b, j)))
             << label << ", indices = " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [](const Rect& a, const Rect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // test b rects are allowed to have 0 w/h, but not be backwards
     ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
  
     // unflipped a vs flipped (empty) b yields false
     EXPECT_TRUE(a.Contains(flip_lr(b))) << label;
     EXPECT_TRUE(a.Contains(flip_tb(b))) << label;
     EXPECT_TRUE(a.Contains(flip_lrtb(b))) << label;
  
     // flipped (empty) a vs unflipped b yields false
     EXPECT_FALSE(flip_lr(a).Contains(b)) << label;
     EXPECT_FALSE(flip_tb(a).Contains(b)) << label;
     EXPECT_FALSE(flip_lrtb(a).Contains(b)) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_FALSE(flip_lr(a).Contains(flip_lr(b))) << label;
     EXPECT_FALSE(flip_tb(a).Contains(flip_tb(b))) << label;
     EXPECT_FALSE(flip_lrtb(a).Contains(flip_lrtb(b))) << label;
   };
  
   auto test_inside = [&check_nans, &check_empty_flips](const Rect& a,
                                                        const Rect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // test b rects are allowed to have 0 w/h, but not be backwards
     ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
  
     std::stringstream stream;
     stream << a << " contains " << b;
     auto label = stream.str();
  
     EXPECT_TRUE(a.Contains(b)) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   auto test_not_inside = [&check_nans, &check_empty_flips](const Rect& a,
                                                            const Rect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // If b was empty, it would be contained and should not be tested with
     // this function - use |test_inside| instead.
     ASSERT_FALSE(b.IsEmpty()) << b;
  
     std::stringstream stream;
     stream << a << " contains " << b;
     auto label = stream.str();
  
     EXPECT_FALSE(a.Contains(b)) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
  
     test_inside(a, a);
   }
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(0, 0, 0, 0);
  
     test_inside(a, b);
   }
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(150, 150, 20, 20);
  
     test_inside(a, b);
   }
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(150, 150, 100, 100);
  
     test_not_inside(a, b);
   }
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(50, 50, 100, 100);
  
     test_not_inside(a, b);
   }
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(0, 0, 300, 300);
  
     test_not_inside(a, b);
   }
   {
     auto a = Rect::MakeMaximum();
     auto b = Rect::MakeXYWH(0, 0, 300, 300);
  
     test_inside(a, b);
   }
 }

References impeller::saturated::b, impeller::TRect< T >::Contains(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [341/523]

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

Definition at line 668 of file rect_unittests.cc.

                          {
   // Using fractional-power-of-2 friendly values for equality tests
   Rect rect = Rect::MakeLTRB(5.125f, 10.25f, 20.625f, 25.375f);
   Rect copy = rect;
  
   EXPECT_EQ(rect, copy);
   EXPECT_EQ(copy.GetLeft(), 5.125f);
   EXPECT_EQ(copy.GetTop(), 10.25f);
   EXPECT_EQ(copy.GetRight(), 20.625f);
   EXPECT_EQ(copy.GetBottom(), 25.375f);
   EXPECT_EQ(copy.GetX(), 5.125f);
   EXPECT_EQ(copy.GetY(), 10.25f);
   EXPECT_EQ(copy.GetWidth(), 15.5f);
   EXPECT_EQ(copy.GetHeight(), 15.125f);
   EXPECT_FALSE(copy.IsEmpty());
   EXPECT_TRUE(copy.IsFinite());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [342/523]

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

Definition at line 2688 of file rect_unittests.cc.

                            {
   Rect cull_rect = Rect::MakeLTRB(20, 20, 40, 40);
  
   auto check_nans = [&cull_rect](const Rect& diff_rect,
                                  const std::string& label) {
     EXPECT_TRUE(cull_rect.IsFinite()) << label;
     EXPECT_TRUE(diff_rect.IsFinite()) << label;
  
     for (int i = 1; i < 16; i++) {
       // NaN in cull_rect produces empty
       EXPECT_FALSE(swap_nan(cull_rect, i).Cutout(diff_rect).has_value())
           << label << ", index " << i;
       EXPECT_EQ(swap_nan(cull_rect, i).CutoutOrEmpty(diff_rect), Rect())
           << label << ", index " << i;
  
       // NaN in diff_rect is nop
       EXPECT_TRUE(cull_rect.Cutout(swap_nan(diff_rect, i)).has_value())
           << label << ", index " << i;
       EXPECT_EQ(cull_rect.CutoutOrEmpty(swap_nan(diff_rect, i)), cull_rect)
           << label << ", index " << i;
  
       for (int j = 1; j < 16; j++) {
         // NaN in both is also empty
         EXPECT_FALSE(
             swap_nan(cull_rect, i).Cutout(swap_nan(diff_rect, j)).has_value())
             << label << ", indices " << i << ", " << j;
         EXPECT_EQ(swap_nan(cull_rect, i).CutoutOrEmpty(swap_nan(diff_rect, j)),
                   Rect())
             << label << ", indices " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [&cull_rect](const Rect& diff_rect,
                                         const std::string& label) {
     EXPECT_FALSE(cull_rect.IsEmpty()) << label;
     EXPECT_FALSE(diff_rect.IsEmpty()) << label;
  
     // unflipped cull_rect vs flipped(empty) diff_rect
     // == cull_rect
     EXPECT_TRUE(cull_rect.Cutout(flip_lr(diff_rect)).has_value()) << label;
     EXPECT_EQ(cull_rect.Cutout(flip_lr(diff_rect)), cull_rect) << label;
     EXPECT_TRUE(cull_rect.Cutout(flip_tb(diff_rect)).has_value()) << label;
     EXPECT_EQ(cull_rect.Cutout(flip_tb(diff_rect)), cull_rect) << label;
     EXPECT_TRUE(cull_rect.Cutout(flip_lrtb(diff_rect)).has_value()) << label;
     EXPECT_EQ(cull_rect.Cutout(flip_lrtb(diff_rect)), cull_rect) << label;
  
     // flipped(empty) cull_rect vs unflipped diff_rect
     // == empty
     EXPECT_FALSE(flip_lr(cull_rect).Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(diff_rect), Rect()) << label;
     EXPECT_FALSE(flip_tb(cull_rect).Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(diff_rect), Rect()) << label;
     EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(diff_rect), Rect()) << label;
  
     // flipped(empty) cull_rect vs flipped(empty) diff_rect
     // == empty
     EXPECT_FALSE(flip_lr(cull_rect).Cutout(flip_lr(diff_rect)).has_value())
         << label;
     EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(flip_lr(diff_rect)), Rect())
         << label;
     EXPECT_FALSE(flip_tb(cull_rect).Cutout(flip_tb(diff_rect)).has_value())
         << label;
     EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(flip_tb(diff_rect)), Rect())
         << label;
     EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(flip_lrtb(diff_rect)).has_value())
         << label;
     EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(flip_lrtb(diff_rect)), Rect())
         << label;
   };
  
   auto non_reducing = [&cull_rect, &check_empty_flips, &check_nans](
                           const Rect& diff_rect, const std::string& label) {
     EXPECT_EQ(cull_rect.Cutout(diff_rect), cull_rect) << label;
     EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), cull_rect) << label;
     check_empty_flips(diff_rect, label);
     check_nans(diff_rect, label);
   };
  
   auto reducing = [&cull_rect, &check_empty_flips, &check_nans](
                       const Rect& diff_rect, const Rect& result_rect,
                       const std::string& label) {
     EXPECT_TRUE(!result_rect.IsEmpty());
     EXPECT_EQ(cull_rect.Cutout(diff_rect), result_rect) << label;
     EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), result_rect) << label;
     check_empty_flips(diff_rect, label);
     check_nans(diff_rect, label);
   };
  
   auto emptying = [&cull_rect, &check_empty_flips, &check_nans](
                       const Rect& diff_rect, const std::string& label) {
     EXPECT_FALSE(cull_rect.Cutout(diff_rect).has_value()) << label;
     EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), Rect()) << label;
     check_empty_flips(diff_rect, label);
     check_nans(diff_rect, label);
   };
  
   // Skim the corners and edge
   non_reducing(Rect::MakeLTRB(10, 10, 20, 20), "outside UL corner");
   non_reducing(Rect::MakeLTRB(20, 10, 40, 20), "Above");
   non_reducing(Rect::MakeLTRB(40, 10, 50, 20), "outside UR corner");
   non_reducing(Rect::MakeLTRB(40, 20, 50, 40), "Right");
   non_reducing(Rect::MakeLTRB(40, 40, 50, 50), "outside LR corner");
   non_reducing(Rect::MakeLTRB(20, 40, 40, 50), "Below");
   non_reducing(Rect::MakeLTRB(10, 40, 20, 50), "outside LR corner");
   non_reducing(Rect::MakeLTRB(10, 20, 20, 40), "Left");
  
   // Overlap corners
   non_reducing(Rect::MakeLTRB(15, 15, 25, 25), "covering UL corner");
   non_reducing(Rect::MakeLTRB(35, 15, 45, 25), "covering UR corner");
   non_reducing(Rect::MakeLTRB(35, 35, 45, 45), "covering LR corner");
   non_reducing(Rect::MakeLTRB(15, 35, 25, 45), "covering LL corner");
  
   // Overlap edges, but not across an entire side
   non_reducing(Rect::MakeLTRB(20, 15, 39, 25), "Top edge left-biased");
   non_reducing(Rect::MakeLTRB(21, 15, 40, 25), "Top edge, right biased");
   non_reducing(Rect::MakeLTRB(35, 20, 45, 39), "Right edge, top-biased");
   non_reducing(Rect::MakeLTRB(35, 21, 45, 40), "Right edge, bottom-biased");
   non_reducing(Rect::MakeLTRB(20, 35, 39, 45), "Bottom edge, left-biased");
   non_reducing(Rect::MakeLTRB(21, 35, 40, 45), "Bottom edge, right-biased");
   non_reducing(Rect::MakeLTRB(15, 20, 25, 39), "Left edge, top-biased");
   non_reducing(Rect::MakeLTRB(15, 21, 25, 40), "Left edge, bottom-biased");
  
   // Slice all the way through the middle
   non_reducing(Rect::MakeLTRB(25, 15, 35, 45), "Vertical interior slice");
   non_reducing(Rect::MakeLTRB(15, 25, 45, 35), "Horizontal interior slice");
  
   // Slice off each edge
   reducing(Rect::MakeLTRB(20, 15, 40, 25),  //
            Rect::MakeLTRB(20, 25, 40, 40),  //
            "Slice off top");
   reducing(Rect::MakeLTRB(35, 20, 45, 40),  //
            Rect::MakeLTRB(20, 20, 35, 40),  //
            "Slice off right");
   reducing(Rect::MakeLTRB(20, 35, 40, 45),  //
            Rect::MakeLTRB(20, 20, 40, 35),  //
            "Slice off bottom");
   reducing(Rect::MakeLTRB(15, 20, 25, 40),  //
            Rect::MakeLTRB(25, 20, 40, 40),  //
            "Slice off left");
  
   // cull rect contains diff rect
   non_reducing(Rect::MakeLTRB(21, 21, 39, 39), "Contained, non-covering");
  
   // cull rect equals diff rect
   emptying(cull_rect, "Perfectly covering");
  
   // diff rect contains cull rect
   emptying(Rect::MakeLTRB(15, 15, 45, 45), "Smothering");
 }

References impeller::TRect< T >::Cutout(), impeller::TRect< T >::CutoutOrEmpty(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::TRect< Scalar >::MakeLTRB(), and swap_nan().

◆ TEST() [343/523]

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

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::IsFinite().

◆ TEST() [344/523]

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

Definition at line 3030 of file rect_unittests.cc.

                                {
   auto r = Rect::MakeLTRB(1, 2, 3, 4);
  
   EXPECT_EQ(r.GetLeft(), 1);
   EXPECT_EQ(r.GetTop(), 2);
   EXPECT_EQ(r.GetRight(), 3);
   EXPECT_EQ(r.GetBottom(), 4);
  
   EXPECT_POINT_NEAR(r.GetLeftTop(), Point(1, 2));
   EXPECT_POINT_NEAR(r.GetRightTop(), Point(3, 2));
   EXPECT_POINT_NEAR(r.GetLeftBottom(), Point(1, 4));
   EXPECT_POINT_NEAR(r.GetRightBottom(), Point(3, 4));
 }

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

◆ TEST() [345/523]

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

Definition at line 809 of file rect_unittests.cc.

                                           {
   Rect rect = Rect::MakeLTRB(50, 50, 100, 100);
  
   auto test = [&rect](Scalar l, Scalar t, Scalar r, Scalar b,
                       const std::string& label) {
     EXPECT_FALSE(rect.IntersectsWithRect(Rect::MakeLTRB(l, b, r, t)))
         << label << " with Top/Bottom swapped";
     EXPECT_FALSE(rect.IntersectsWithRect(Rect::MakeLTRB(r, b, l, t)))
         << label << " with Left/Right swapped";
     EXPECT_FALSE(rect.IntersectsWithRect(Rect::MakeLTRB(r, t, l, b)))
         << label << " with all sides swapped";
   };
  
   test(20, 20, 30, 30, "Above and Left");
   test(70, 20, 80, 30, "Above");
   test(120, 20, 130, 30, "Above and Right");
   test(120, 70, 130, 80, "Right");
   test(120, 120, 130, 130, "Below and Right");
   test(70, 120, 80, 130, "Below");
   test(20, 120, 30, 130, "Below and Left");
   test(20, 70, 30, 80, "Left");
  
   test(70, 70, 80, 80, "Inside");
  
   test(40, 70, 60, 80, "Straddling Left");
   test(70, 40, 80, 60, "Straddling Top");
   test(90, 70, 110, 80, "Straddling Right");
   test(70, 90, 80, 110, "Straddling Bottom");
 }

References impeller::saturated::b, impeller::TRect< T >::IntersectsWithRect(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [346/523]

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

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::IsFinite().

◆ TEST() [347/523]

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

Definition at line 1250 of file rect_unittests.cc.

                            {
   auto rect = Rect::MakeLTRB(100, 100, 200, 200);
  
   // Expand(T amount)
   EXPECT_EQ(rect.Expand(10), Rect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(-10), Rect::MakeLTRB(110, 110, 190, 190));
  
   // Expand(amount, amount)
   EXPECT_EQ(rect.Expand(10, 10), Rect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(10, -10), Rect::MakeLTRB(90, 110, 210, 190));
   EXPECT_EQ(rect.Expand(-10, 10), Rect::MakeLTRB(110, 90, 190, 210));
   EXPECT_EQ(rect.Expand(-10, -10), Rect::MakeLTRB(110, 110, 190, 190));
  
   // Expand(amount, amount, amount, amount)
   EXPECT_EQ(rect.Expand(10, 20, 30, 40), Rect::MakeLTRB(90, 80, 230, 240));
   EXPECT_EQ(rect.Expand(-10, 20, 30, 40), Rect::MakeLTRB(110, 80, 230, 240));
   EXPECT_EQ(rect.Expand(10, -20, 30, 40), Rect::MakeLTRB(90, 120, 230, 240));
   EXPECT_EQ(rect.Expand(10, 20, -30, 40), Rect::MakeLTRB(90, 80, 170, 240));
   EXPECT_EQ(rect.Expand(10, 20, 30, -40), Rect::MakeLTRB(90, 80, 230, 160));
  
   // Expand(Point amount)
   EXPECT_EQ(rect.Expand(Point{10, 10}), Rect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(Point{10, -10}), Rect::MakeLTRB(90, 110, 210, 190));
   EXPECT_EQ(rect.Expand(Point{-10, 10}), Rect::MakeLTRB(110, 90, 190, 210));
   EXPECT_EQ(rect.Expand(Point{-10, -10}), Rect::MakeLTRB(110, 110, 190, 190));
  
   // Expand(Size amount)
   EXPECT_EQ(rect.Expand(Size{10, 10}), Rect::MakeLTRB(90, 90, 210, 210));
   EXPECT_EQ(rect.Expand(Size{10, -10}), Rect::MakeLTRB(90, 110, 210, 190));
   EXPECT_EQ(rect.Expand(Size{-10, 10}), Rect::MakeLTRB(110, 90, 190, 210));
   EXPECT_EQ(rect.Expand(Size{-10, -10}), Rect::MakeLTRB(110, 110, 190, 190));
 }

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [348/523]

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

Definition at line 164 of file rect_unittests.cc.

                               {
   IRect irect = IRect::MakeLTRB(10, 20, 30, 40);
   Rect rect = Rect::Make(irect);
  
   EXPECT_EQ(rect.GetLeft(), 10);
   EXPECT_EQ(rect.GetTop(), 20);
   EXPECT_EQ(rect.GetRight(), 30);
   EXPECT_EQ(rect.GetBottom(), 40);
  
   // The following do not compile
   // IRect irect2 = IRect::Make(rect);
   // IRect irect2 = IRect::Make(irect);
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< Scalar >::Make(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [349/523]

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

Definition at line 654 of file rect_unittests.cc.

                              {
   EXPECT_EQ(Rect(Rect::MakeXYWH(2, 3, 7, 15)),
             Rect::MakeXYWH(2.0, 3.0, 7.0, 15.0));
   EXPECT_EQ(Rect(Rect::MakeLTRB(2, 3, 7, 15)),
             Rect::MakeLTRB(2.0, 3.0, 7.0, 15.0));
 }

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

◆ TEST() [350/523]

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

Definition at line 1034 of file rect_unittests.cc.

                                             {
   {
     // Checks for expected matrix values
  
     auto r = Rect::MakeXYWH(100, 200, 200, 400);
  
     EXPECT_EQ(r.GetNormalizingTransform(),
               Matrix::MakeScale({0.005, 0.0025, 1.0}) *
                   Matrix::MakeTranslation({-100, -200}));
   }
  
   {
     // Checks for expected transform of points relative to the rect
  
     auto r = Rect::MakeLTRB(300, 500, 400, 700);
     auto m = r.GetNormalizingTransform();
  
     // The 4 corners of the rect => (0, 0) to (1, 1)
     EXPECT_EQ(m * Point(300, 500), Point(0, 0));
     EXPECT_EQ(m * Point(400, 500), Point(1, 0));
     EXPECT_EQ(m * Point(400, 700), Point(1, 1));
     EXPECT_EQ(m * Point(300, 700), Point(0, 1));
  
     // The center => (0.5, 0.5)
     EXPECT_EQ(m * Point(350, 600), Point(0.5, 0.5));
  
     // Outside the 4 corners => (-1, -1) to (2, 2)
     EXPECT_EQ(m * Point(200, 300), Point(-1, -1));
     EXPECT_EQ(m * Point(500, 300), Point(2, -1));
     EXPECT_EQ(m * Point(500, 900), Point(2, 2));
     EXPECT_EQ(m * Point(200, 900), Point(-1, 2));
   }
  
   {
     // Checks for behavior with empty rects
  
     auto zero = Matrix::MakeScale({0.0, 0.0, 1.0});
  
     // Empty for width and/or height == 0
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 0, 10).GetNormalizingTransform(), zero);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, 0).GetNormalizingTransform(), zero);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 0, 0).GetNormalizingTransform(), zero);
  
     // Empty for width and/or height < 0
     EXPECT_EQ(Rect::MakeXYWH(10, 10, -1, 10).GetNormalizingTransform(), zero);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, -1).GetNormalizingTransform(), zero);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, -1, -1).GetNormalizingTransform(), zero);
   }
  
   {
     // Checks for behavior with non-finite rects
  
     auto z = Matrix::MakeScale({0.0, 0.0, 1.0});
     auto nan = std::numeric_limits<Scalar>::quiet_NaN();
     auto inf = std::numeric_limits<Scalar>::infinity();
  
     // Non-finite for width and/or height == nan
     EXPECT_EQ(Rect::MakeXYWH(10, 10, nan, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, nan).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, nan, nan).GetNormalizingTransform(), z);
  
     // Non-finite for width and/or height == inf
     EXPECT_EQ(Rect::MakeXYWH(10, 10, inf, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, inf).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, inf, inf).GetNormalizingTransform(), z);
  
     // Non-finite for width and/or height == -inf
     EXPECT_EQ(Rect::MakeXYWH(10, 10, -inf, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, -inf).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, 10, -inf, -inf).GetNormalizingTransform(), z);
  
     // Non-finite for origin X and/or Y == nan
     EXPECT_EQ(Rect::MakeXYWH(nan, 10, 10, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, nan, 10, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(nan, nan, 10, 10).GetNormalizingTransform(), z);
  
     // Non-finite for origin X and/or Y == inf
     EXPECT_EQ(Rect::MakeXYWH(inf, 10, 10, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, inf, 10, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(inf, inf, 10, 10).GetNormalizingTransform(), z);
  
     // Non-finite for origin X and/or Y == -inf
     EXPECT_EQ(Rect::MakeXYWH(-inf, 10, 10, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(10, -inf, 10, 10).GetNormalizingTransform(), z);
     EXPECT_EQ(Rect::MakeXYWH(-inf, -inf, 10, 10).GetNormalizingTransform(), z);
   }
 }

References impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [351/523]

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

Definition at line 2959 of file rect_unittests.cc.

                               {
   {
     Rect r = Rect::MakeXYWH(100, 200, 300, 400);
     auto points = r.GetPoints();
     EXPECT_POINT_NEAR(points[0], Point(100, 200));
     EXPECT_POINT_NEAR(points[1], Point(400, 200));
     EXPECT_POINT_NEAR(points[2], Point(100, 600));
     EXPECT_POINT_NEAR(points[3], Point(400, 600));
   }
  
   {
     Rect r = Rect::MakeMaximum();
     auto points = r.GetPoints();
     EXPECT_EQ(points[0], Point(std::numeric_limits<float>::lowest(),
                                std::numeric_limits<float>::lowest()));
     EXPECT_EQ(points[1], Point(std::numeric_limits<float>::max(),
                                std::numeric_limits<float>::lowest()));
     EXPECT_EQ(points[2], Point(std::numeric_limits<float>::lowest(),
                                std::numeric_limits<float>::max()));
     EXPECT_EQ(points[3], Point(std::numeric_limits<float>::max(),
                                std::numeric_limits<float>::max()));
   }
 }

References EXPECT_POINT_NEAR, impeller::TRect< T >::GetPoints(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and points.

◆ TEST() [352/523]

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

Definition at line 3016 of file rect_unittests.cc.

                                 {
   {
     Rect r = Rect::MakeXYWH(100, 200, 300, 400);
     auto actual = r.GetPositive();
     EXPECT_RECT_NEAR(r, actual);
   }
   {
     Rect r = Rect::MakeXYWH(100, 200, -100, -100);
     auto actual = r.GetPositive();
     Rect expected = Rect::MakeXYWH(0, 100, 100, 100);
     EXPECT_RECT_NEAR(expected, actual);
   }
 }

References EXPECT_RECT_NEAR, impeller::TRect< T >::GetPositive(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [353/523]

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

Definition at line 2990 of file rect_unittests.cc.

                                          {
   Rect r = Rect::MakeXYWH(100, 200, 300, 400);
   auto points = r.GetTransformedPoints(Matrix::MakeTranslation({10, 20}));
   EXPECT_POINT_NEAR(points[0], Point(110, 220));
   EXPECT_POINT_NEAR(points[1], Point(410, 220));
   EXPECT_POINT_NEAR(points[2], Point(110, 620));
   EXPECT_POINT_NEAR(points[3], Point(410, 620));
 }

References EXPECT_POINT_NEAR, impeller::TRect< T >::GetTransformedPoints(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), and points.

◆ TEST() [354/523]

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

Definition at line 1617 of file rect_unittests.cc.

                                  {
   auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
     ASSERT_TRUE(a.IsFinite()) << label;
     ASSERT_TRUE(b.IsFinite()) << label;
  
     for (int i = 1; i < 16; i++) {
       // NaN in a produces empty
       EXPECT_FALSE(swap_nan(a, i).Intersection(b).has_value())
           << label << ", index = " << i;
       // NaN in b produces empty
       EXPECT_FALSE(a.Intersection(swap_nan(b, i)).has_value())
           << label << ", index = " << i;
       // NaN in both is empty
       for (int j = 1; j < 16; j++) {
         EXPECT_FALSE(swap_nan(a, i).Intersection(swap_nan(b, j)).has_value())
             << label << ", indices = " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [](const Rect& a, const Rect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // b is allowed to be empty
  
     // unflipped a vs flipped (empty) b yields a
     EXPECT_FALSE(a.Intersection(flip_lr(b)).has_value()) << label;
     EXPECT_TRUE(a.IntersectionOrEmpty(flip_lr(b)).IsEmpty()) << label;
     EXPECT_FALSE(a.Intersection(flip_tb(b)).has_value()) << label;
     EXPECT_TRUE(a.IntersectionOrEmpty(flip_tb(b)).IsEmpty()) << label;
     EXPECT_FALSE(a.Intersection(flip_lrtb(b)).has_value()) << label;
     EXPECT_TRUE(a.IntersectionOrEmpty(flip_lrtb(b)).IsEmpty()) << label;
  
     // flipped (empty) a vs unflipped b yields b
     EXPECT_FALSE(flip_lr(a).Intersection(b).has_value()) << label;
     EXPECT_TRUE(flip_lr(a).IntersectionOrEmpty(b).IsEmpty()) << label;
     EXPECT_FALSE(flip_tb(a).Intersection(b).has_value()) << label;
     EXPECT_TRUE(flip_tb(a).IntersectionOrEmpty(b).IsEmpty()) << label;
     EXPECT_FALSE(flip_lrtb(a).Intersection(b).has_value()) << label;
     EXPECT_TRUE(flip_lrtb(a).IntersectionOrEmpty(b).IsEmpty()) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_FALSE(flip_lr(a).Intersection(flip_lr(b)).has_value()) << label;
     EXPECT_TRUE(flip_lr(a).IntersectionOrEmpty(flip_lr(b)).IsEmpty()) << label;
     EXPECT_FALSE(flip_tb(a).Intersection(flip_tb(b)).has_value()) << label;
     EXPECT_TRUE(flip_tb(a).IntersectionOrEmpty(flip_tb(b)).IsEmpty()) << label;
     EXPECT_FALSE(flip_lrtb(a).Intersection(flip_lrtb(b)).has_value()) << label;
     EXPECT_TRUE(flip_lrtb(a).IntersectionOrEmpty(flip_lrtb(b)).IsEmpty())
         << label;
   };
  
   auto test_non_empty = [&check_nans, &check_empty_flips](
                             const Rect& a, const Rect& b, const Rect& result) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_TRUE(a.Intersection(b).has_value()) << label;
     EXPECT_TRUE(b.Intersection(a).has_value()) << label;
     EXPECT_EQ(a.Intersection(b), result) << label;
     EXPECT_EQ(b.Intersection(a), result) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   auto test_empty = [&check_nans, &check_empty_flips](const Rect& a,
                                                       const Rect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_FALSE(a.Intersection(b).has_value()) << label;
     EXPECT_TRUE(a.IntersectionOrEmpty(b).IsEmpty()) << label;
     EXPECT_FALSE(b.Intersection(a).has_value()) << label;
     EXPECT_TRUE(b.IntersectionOrEmpty(a).IsEmpty()) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(0, 0, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(10, 10, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = Rect::MakeXYWH(0, 0, 100, 100);
     auto b = Rect::MakeXYWH(10, 10, 100, 100);
     auto expected = Rect::MakeXYWH(10, 10, 90, 90);
  
     test_non_empty(a, b, expected);
   }
  
   {
     auto a = Rect::MakeXYWH(0, 0, 100, 100);
     auto b = Rect::MakeXYWH(100, 100, 100, 100);
  
     test_empty(a, b);
   }
  
   {
     auto a = Rect::MakeMaximum();
     auto b = Rect::MakeXYWH(10, 10, 300, 300);
  
     test_non_empty(a, b, b);
   }
  
   {
     auto a = Rect::MakeMaximum();
     auto b = Rect::MakeMaximum();
  
     test_non_empty(a, b, Rect::MakeMaximum());
   }
 }

References impeller::saturated::b, flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::Intersection(), impeller::TRect< T >::IntersectionOrEmpty(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [355/523]

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

Definition at line 1951 of file rect_unittests.cc.

                                        {
   auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
     ASSERT_TRUE(a.IsFinite()) << label;
     ASSERT_TRUE(b.IsFinite()) << label;
  
     for (int i = 1; i < 16; i++) {
       // NaN in a produces b
       EXPECT_FALSE(swap_nan(a, i).IntersectsWithRect(b))
           << label << ", index = " << i;
       // NaN in b produces a
       EXPECT_FALSE(a.IntersectsWithRect(swap_nan(b, i)))
           << label << ", index = " << i;
       // NaN in both is empty
       for (int j = 1; j < 16; j++) {
         EXPECT_FALSE(swap_nan(a, i).IntersectsWithRect(swap_nan(b, j)))
             << label << ", indices = " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [](const Rect& a, const Rect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // b is allowed to be empty
  
     // unflipped a vs flipped (empty) b yields a
     EXPECT_FALSE(a.IntersectsWithRect(flip_lr(b))) << label;
     EXPECT_FALSE(a.IntersectsWithRect(flip_tb(b))) << label;
     EXPECT_FALSE(a.IntersectsWithRect(flip_lrtb(b))) << label;
  
     // flipped (empty) a vs unflipped b yields b
     EXPECT_FALSE(flip_lr(a).IntersectsWithRect(b)) << label;
     EXPECT_FALSE(flip_tb(a).IntersectsWithRect(b)) << label;
     EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(b)) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_FALSE(flip_lr(a).IntersectsWithRect(flip_lr(b))) << label;
     EXPECT_FALSE(flip_tb(a).IntersectsWithRect(flip_tb(b))) << label;
     EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(flip_lrtb(b))) << label;
   };
  
   auto test_non_empty = [&check_nans, &check_empty_flips](const Rect& a,
                                                           const Rect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_TRUE(a.IntersectsWithRect(b)) << label;
     EXPECT_TRUE(b.IntersectsWithRect(a)) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   auto test_empty = [&check_nans, &check_empty_flips](const Rect& a,
                                                       const Rect& b) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_FALSE(a.IntersectsWithRect(b)) << label;
     EXPECT_FALSE(b.IntersectsWithRect(a)) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(0, 0, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(10, 10, 0, 0);
  
     test_empty(a, b);
   }
  
   {
     auto a = Rect::MakeXYWH(0, 0, 100, 100);
     auto b = Rect::MakeXYWH(10, 10, 100, 100);
  
     test_non_empty(a, b);
   }
  
   {
     auto a = Rect::MakeXYWH(0, 0, 100, 100);
     auto b = Rect::MakeXYWH(100, 100, 100, 100);
  
     test_empty(a, b);
   }
  
   {
     auto a = Rect::MakeMaximum();
     auto b = Rect::MakeXYWH(10, 10, 100, 100);
  
     test_non_empty(a, b);
   }
  
   {
     auto a = Rect::MakeMaximum();
     auto b = Rect::MakeMaximum();
  
     test_non_empty(a, b);
   }
 }

References impeller::saturated::b, flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IntersectsWithRect(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [356/523]

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

Definition at line 620 of file rect_unittests.cc.

                                 {
   Rect rect = Rect::MakeMaximum();
   auto inf = std::numeric_limits<Scalar>::infinity();
   auto min = std::numeric_limits<Scalar>::lowest();
   auto max = std::numeric_limits<Scalar>::max();
  
   EXPECT_EQ(rect.GetLeft(), min);
   EXPECT_EQ(rect.GetTop(), min);
   EXPECT_EQ(rect.GetRight(), max);
   EXPECT_EQ(rect.GetBottom(), max);
   EXPECT_EQ(rect.GetX(), min);
   EXPECT_EQ(rect.GetY(), min);
   EXPECT_EQ(rect.GetWidth(), inf);
   EXPECT_EQ(rect.GetHeight(), inf);
   EXPECT_FALSE(rect.IsEmpty());
   EXPECT_TRUE(rect.IsFinite());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeMaximum().

◆ TEST() [357/523]

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

Definition at line 2999 of file rect_unittests.cc.

                                     {
   {
     std::vector<Point> points{{1, 5}, {4, -1}, {0, 6}};
     auto r = Rect::MakePointBounds(points.begin(), points.end());
     auto expected = Rect::MakeXYWH(0, -1, 4, 7);
     EXPECT_TRUE(r.has_value());
     if (r.has_value()) {
       EXPECT_RECT_NEAR(r.value(), expected);
     }
   }
   {
     std::vector<Point> points;
     std::optional<Rect> r = Rect::MakePointBounds(points.begin(), points.end());
     EXPECT_FALSE(r.has_value());
   }
 }

References EXPECT_RECT_NEAR, impeller::TRect< Scalar >::MakePointBounds(), impeller::TRect< Scalar >::MakeXYWH(), and points.

◆ TEST() [358/523]

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

Definition at line 590 of file rect_unittests.cc.

                              {
   {
     Size s(100, 200);
     Rect r = Rect::MakeSize(s);
     Rect expected = Rect::MakeLTRB(0, 0, 100, 200);
     EXPECT_RECT_NEAR(r, expected);
   }
  
   {
     ISize s(100, 200);
     Rect r = Rect::MakeSize(s);
     Rect expected = Rect::MakeLTRB(0, 0, 100, 200);
     EXPECT_RECT_NEAR(r, expected);
   }
  
   {
     Size s(100, 200);
     IRect r = IRect::MakeSize(s);
     IRect expected = IRect::MakeLTRB(0, 0, 100, 200);
     EXPECT_EQ(r, expected);
   }
  
   {
     ISize s(100, 200);
     IRect r = IRect::MakeSize(s);
     IRect expected = IRect::MakeLTRB(0, 0, 100, 200);
     EXPECT_EQ(r, expected);
   }
 }

References EXPECT_RECT_NEAR, impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< T >::MakeSize(), and impeller::TRect< Scalar >::MakeSize().

◆ TEST() [359/523]

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

Definition at line 702 of file rect_unittests.cc.

                                           {
   {
     Rect r = Rect::MakeOriginSize({10, 20}, {50, 40});
     EXPECT_EQ(r.GetOrigin(), Point(10, 20));
     EXPECT_EQ(r.GetSize(), Size(50, 40));
     EXPECT_EQ(r.GetX(), 10);
     EXPECT_EQ(r.GetY(), 20);
     EXPECT_EQ(r.GetWidth(), 50);
     EXPECT_EQ(r.GetHeight(), 40);
     auto expected_array = std::array<Scalar, 4>{10, 20, 50, 40};
     EXPECT_EQ(r.GetXYWH(), expected_array);
   }
  
   {
     Rect r = Rect::MakeLTRB(10, 20, 50, 40);
     EXPECT_EQ(r.GetOrigin(), Point(10, 20));
     EXPECT_EQ(r.GetSize(), Size(40, 20));
     EXPECT_EQ(r.GetX(), 10);
     EXPECT_EQ(r.GetY(), 20);
     EXPECT_EQ(r.GetWidth(), 40);
     EXPECT_EQ(r.GetHeight(), 20);
     auto expected_array = std::array<Scalar, 4>{10, 20, 40, 20};
     EXPECT_EQ(r.GetXYWH(), expected_array);
   }
 }

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetXYWH(), impeller::TRect< T >::GetY(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::MakeOriginSize().

◆ TEST() [360/523]

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

Definition at line 384 of file rect_unittests.cc.

                                  {
   auto min = std::numeric_limits<Scalar>::lowest();
   auto max = std::numeric_limits<Scalar>::max();
   auto inf = std::numeric_limits<Scalar>::infinity();
  
   // 8 cases:
   //   finite negative X, max W
   //   ~min X, ~max W
   //   finite negative Y, max H
   //   ~min Y, ~max H
   //   finite positive X, min W
   //   ~min X, ~min W
   //   finite positive Y, min H
   //   ~min Y, ~min H
  
   // a small finite value subtracted from a max value will remain max
   // a very large finite value (like min) subtracted from max will go to inf
  
   {
     Rect rect = Rect::MakeLTRB(-5.0f, 10.0f, max, 25.0f);
  
     EXPECT_EQ(rect.GetLeft(), -5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), max);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), -5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), max);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(min + 5.0f, 10.0f, max - 5.0f, 25.0f);
  
     EXPECT_EQ(rect.GetLeft(), min + 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), max - 5.0f);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), min + 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), inf);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(5.0f, -10.0f, 20.0f, max);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), -10.0f);
     EXPECT_EQ(rect.GetRight(), 20.0f);
     EXPECT_EQ(rect.GetBottom(), max);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), -10.0f);
     EXPECT_EQ(rect.GetWidth(), 15.0f);
     EXPECT_EQ(rect.GetHeight(), max);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(5.0f, min + 10.0f, 20.0f, max - 15.0f);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), min + 10.0f);
     EXPECT_EQ(rect.GetRight(), 20.0f);
     EXPECT_EQ(rect.GetBottom(), max - 15.0f);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), min + 10.0f);
     EXPECT_EQ(rect.GetWidth(), 15.0f);
     EXPECT_EQ(rect.GetHeight(), inf);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(5.0f, 10.0f, min, 25.0f);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), min);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), min);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(max - 5.0f, 10.0f, min + 10.0f, 25.0f);
  
     EXPECT_EQ(rect.GetLeft(), max - 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), min + 10.0f);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), max - 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), -inf);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(5.0f, 10.0f, 20.0f, min);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), 20.0f);
     EXPECT_EQ(rect.GetBottom(), min);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), 15.0f);
     EXPECT_EQ(rect.GetHeight(), min);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeLTRB(5.0f, max - 5.0f, 20.0f, min + 10.0f);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), max - 5.0f);
     EXPECT_EQ(rect.GetRight(), 20.0f);
     EXPECT_EQ(rect.GetBottom(), min + 10.0f);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), max - 5.0f);
     EXPECT_EQ(rect.GetWidth(), 15.0f);
     EXPECT_EQ(rect.GetHeight(), -inf);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [361/523]

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

Definition at line 178 of file rect_unittests.cc.

                                  {
   auto min = std::numeric_limits<Scalar>::lowest();
   auto max = std::numeric_limits<Scalar>::max();
   auto inf = std::numeric_limits<Scalar>::infinity();
  
   // 8 cases:
   //   finite X, max W
   //   max X, max W
   //   finite Y, max H
   //   max Y, max H
   //   finite X, min W
   //   min X, min W
   //   finite Y, min H
   //   min Y, min H
  
   // a small finite value added to a max value will remain max
   // a very large finite value (like max) added to max will go to infinity
  
   {
     Rect rect = Rect::MakeXYWH(5.0, 10.0f, max, 15.0f);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), max);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), max);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(max, 10.0f, max, 15.0f);
  
     EXPECT_EQ(rect.GetLeft(), max);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), inf);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), max);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), inf);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_FALSE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(5.0f, 10.0f, 20.0f, max);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), 25.0f);
     EXPECT_EQ(rect.GetBottom(), max);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), 20.0f);
     EXPECT_EQ(rect.GetHeight(), max);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(5.0f, max, 20.0f, max);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), max);
     EXPECT_EQ(rect.GetRight(), 25.0f);
     EXPECT_EQ(rect.GetBottom(), inf);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), max);
     EXPECT_EQ(rect.GetWidth(), 20.0f);
     EXPECT_EQ(rect.GetHeight(), inf);
     EXPECT_FALSE(rect.IsEmpty());
     EXPECT_FALSE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(5.0, 10.0f, min, 15.0f);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), min);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), min);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(min, 10.0f, min, 15.0f);
  
     EXPECT_EQ(rect.GetLeft(), min);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), -inf);
     EXPECT_EQ(rect.GetBottom(), 25.0f);
     EXPECT_EQ(rect.GetX(), min);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), -inf);
     EXPECT_EQ(rect.GetHeight(), 15.0f);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_FALSE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(5.0f, 10.0f, 20.0f, min);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), 10.0f);
     EXPECT_EQ(rect.GetRight(), 25.0f);
     EXPECT_EQ(rect.GetBottom(), min);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), 10.0f);
     EXPECT_EQ(rect.GetWidth(), 20.0f);
     EXPECT_EQ(rect.GetHeight(), min);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_TRUE(rect.IsFinite());
   }
  
   {
     Rect rect = Rect::MakeXYWH(5.0f, min, 20.0f, min);
  
     EXPECT_EQ(rect.GetLeft(), 5.0f);
     EXPECT_EQ(rect.GetTop(), min);
     EXPECT_EQ(rect.GetRight(), 25.0f);
     EXPECT_EQ(rect.GetBottom(), -inf);
     EXPECT_EQ(rect.GetX(), 5.0f);
     EXPECT_EQ(rect.GetY(), min);
     EXPECT_EQ(rect.GetWidth(), 20.0f);
     EXPECT_EQ(rect.GetHeight(), -inf);
     EXPECT_TRUE(rect.IsEmpty());
     EXPECT_FALSE(rect.IsFinite());
   }
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [362/523]

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

Definition at line 3044 of file rect_unittests.cc.

                             {
   {
     auto r = Rect::MakeLTRB(-100, -100, 100, 100);
     auto actual = r.Project(r);
     auto expected = Rect::MakeLTRB(0, 0, 1, 1);
     EXPECT_RECT_NEAR(expected, actual);
   }
   {
     auto r = Rect::MakeLTRB(-100, -100, 100, 100);
     auto actual = r.Project(Rect::MakeLTRB(0, 0, 100, 100));
     auto expected = Rect::MakeLTRB(0.5, 0.5, 1, 1);
     EXPECT_RECT_NEAR(expected, actual);
   }
 }

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

◆ TEST() [363/523]

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

Definition at line 3083 of file rect_unittests.cc.

                           {
   {
     auto r = Rect::MakeLTRB(-100, -200, 300, 400);
     EXPECT_EQ(Rect::Round(r), r);
   }
   {
     auto r = Rect::MakeLTRB(-100.4, -200.4, 300.4, 400.4);
     EXPECT_EQ(Rect::Round(r), Rect::MakeLTRB(-100, -200, 300, 400));
   }
   {
     auto r = Rect::MakeLTRB(-100.5, -200.5, 300.5, 400.5);
     EXPECT_EQ(Rect::Round(r), Rect::MakeLTRB(-101, -201, 301, 401));
   }
 }

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

◆ TEST() [364/523]

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

Definition at line 3059 of file rect_unittests.cc.

                              {
   {
     auto r = Rect::MakeLTRB(-100, -200, 300, 400);
     EXPECT_EQ(Rect::RoundOut(r), r);
   }
   {
     auto r = Rect::MakeLTRB(-100.1, -200.1, 300.1, 400.1);
     EXPECT_EQ(Rect::RoundOut(r), Rect::MakeLTRB(-101, -201, 301, 401));
   }
 }

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

◆ TEST() [365/523]

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

Definition at line 754 of file rect_unittests.cc.

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

References impeller::TRect< T >::RoundOut(), and impeller::TRect< Scalar >::RoundOut().

◆ TEST() [366/523]

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

Definition at line 762 of file rect_unittests.cc.

                                    {
   Rect rect = Rect::MakeLTRB(5.125f, 10.75f, 20.625f, 25.375f);
  
   EXPECT_EQ(Rect::RoundOut(rect), Rect::MakeLTRB(5.0f, 10.0f, 21.0f, 26.0f));
  
   EXPECT_EQ(IRect::RoundOut(rect), IRect::MakeLTRB(5, 10, 21, 26));
 }

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

◆ TEST() [367/523]

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

Definition at line 770 of file rect_unittests.cc.

                                         {
   auto test = [](int corners) {
     EXPECT_TRUE(corners >= 0 && corners <= 0xf);
     Scalar l, t, r, b;
     int64_t il, it, ir, ib;
     l = il = 50;
     t = it = 50;
     r = ir = 80;
     b = ib = 80;
     if ((corners & (1 << 0)) != 0) {
       l = -1E20;
       il = std::numeric_limits<int64_t>::min();
     }
     if ((corners & (1 << 1)) != 0) {
       t = -1E20;
       it = std::numeric_limits<int64_t>::min();
     }
     if ((corners & (1 << 2)) != 0) {
       r = +1E20;
       ir = std::numeric_limits<int64_t>::max();
     }
     if ((corners & (1 << 3)) != 0) {
       b = +1E20;
       ib = std::numeric_limits<int64_t>::max();
     }
  
     Rect rect = Rect::MakeLTRB(l, t, r, b);
     IRect irect = IRect::RoundOut(rect);
     EXPECT_EQ(irect.GetLeft(), il) << corners;
     EXPECT_EQ(irect.GetTop(), it) << corners;
     EXPECT_EQ(irect.GetRight(), ir) << corners;
     EXPECT_EQ(irect.GetBottom(), ib) << corners;
   };
  
   for (int corners = 0; corners <= 15; corners++) {
     test(corners);
   }
 }

References impeller::saturated::b, impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< T >::RoundOut().

◆ TEST() [368/523]

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

Definition at line 929 of file rect_unittests.cc.

                           {
   auto test1 = [](Rect rect, Scalar scale) {
     Rect expected = Rect::MakeXYWH(rect.GetX() * scale,      //
                                    rect.GetY() * scale,      //
                                    rect.GetWidth() * scale,  //
                                    rect.GetHeight() * scale);
  
     EXPECT_RECT_NEAR(rect.Scale(scale), expected)  //
         << rect << " * " << scale;
     EXPECT_RECT_NEAR(rect.Scale(scale, scale), expected)  //
         << rect << " * " << scale;
     EXPECT_RECT_NEAR(rect.Scale(Point(scale, scale)), expected)  //
         << rect << " * " << scale;
     EXPECT_RECT_NEAR(rect.Scale(Size(scale, scale)), expected)  //
         << rect << " * " << scale;
   };
  
   auto test2 = [&test1](Rect rect, Scalar scale_x, Scalar scale_y) {
     Rect expected = Rect::MakeXYWH(rect.GetX() * scale_x,      //
                                    rect.GetY() * scale_y,      //
                                    rect.GetWidth() * scale_x,  //
                                    rect.GetHeight() * scale_y);
  
     EXPECT_RECT_NEAR(rect.Scale(scale_x, scale_y), expected)  //
         << rect << " * " << scale_x << ", " << scale_y;
     EXPECT_RECT_NEAR(rect.Scale(Point(scale_x, scale_y)), expected)  //
         << rect << " * " << scale_x << ", " << scale_y;
     EXPECT_RECT_NEAR(rect.Scale(Size(scale_x, scale_y)), expected)  //
         << rect << " * " << scale_x << ", " << scale_y;
  
     test1(rect, scale_x);
     test1(rect, scale_y);
   };
  
   test2(Rect::MakeLTRB(10, 15, 100, 150), 1.0, 0.0);
   test2(Rect::MakeLTRB(10, 15, 100, 150), 0.0, 1.0);
   test2(Rect::MakeLTRB(10, 15, 100, 150), 0.0, 0.0);
   test2(Rect::MakeLTRB(10, 15, 100, 150), 2.5, 3.5);
   test2(Rect::MakeLTRB(10, 15, 100, 150), 3.5, 2.5);
   test2(Rect::MakeLTRB(10, 15, -100, 150), 2.5, 3.5);
   test2(Rect::MakeLTRB(10, 15, 100, -150), 2.5, 3.5);
   test2(Rect::MakeLTRB(10, 15, 100, 150), -2.5, 3.5);
   test2(Rect::MakeLTRB(10, 15, 100, 150), 2.5, -3.5);
 }

References EXPECT_RECT_NEAR, impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::TRect< T >::Scale().

◆ TEST() [369/523]

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

Definition at line 2983 of file rect_unittests.cc.

                           {
   auto r = Rect::MakeLTRB(0, 0, 100, 100);
  
   EXPECT_EQ(r.Shift(Point(10, 5)), Rect::MakeLTRB(10, 5, 110, 105));
   EXPECT_EQ(r.Shift(Point(-10, -5)), Rect::MakeLTRB(-10, -5, 90, 95));
 }

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [370/523]

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

Definition at line 73 of file rect_unittests.cc.

                                {
   // Using fractional-power-of-2 friendly values for equality tests
   Rect rect = Rect::MakeLTRB(5.125f, 10.25f, 20.625f, 25.375f);
  
   EXPECT_EQ(rect.GetLeft(), 5.125f);
   EXPECT_EQ(rect.GetTop(), 10.25f);
   EXPECT_EQ(rect.GetRight(), 20.625f);
   EXPECT_EQ(rect.GetBottom(), 25.375f);
   EXPECT_EQ(rect.GetX(), 5.125f);
   EXPECT_EQ(rect.GetY(), 10.25f);
   EXPECT_EQ(rect.GetWidth(), 15.5f);
   EXPECT_EQ(rect.GetHeight(), 15.125f);
   EXPECT_FALSE(rect.IsEmpty());
   EXPECT_TRUE(rect.IsFinite());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [371/523]

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

Definition at line 133 of file rect_unittests.cc.

                              {
   // Using fractional-power-of-2 friendly values for equality tests
   Rect rect = Rect::MakeWH(15.5f, 15.125f);
  
   EXPECT_EQ(rect.GetLeft(), 0.0f);
   EXPECT_EQ(rect.GetTop(), 0.0f);
   EXPECT_EQ(rect.GetRight(), 15.5f);
   EXPECT_EQ(rect.GetBottom(), 15.125f);
   EXPECT_EQ(rect.GetX(), 0.0f);
   EXPECT_EQ(rect.GetY(), 0.0f);
   EXPECT_EQ(rect.GetWidth(), 15.5f);
   EXPECT_EQ(rect.GetHeight(), 15.125f);
   EXPECT_FALSE(rect.IsEmpty());
   EXPECT_TRUE(rect.IsFinite());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeWH().

◆ TEST() [372/523]

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

Definition at line 103 of file rect_unittests.cc.

                                {
   // Using fractional-power-of-2 friendly values for equality tests
   Rect rect = Rect::MakeXYWH(5.125f, 10.25f, 15.5f, 15.125f);
  
   EXPECT_EQ(rect.GetLeft(), 5.125f);
   EXPECT_EQ(rect.GetTop(), 10.25f);
   EXPECT_EQ(rect.GetRight(), 20.625f);
   EXPECT_EQ(rect.GetBottom(), 25.375f);
   EXPECT_EQ(rect.GetX(), 5.125f);
   EXPECT_EQ(rect.GetY(), 10.25f);
   EXPECT_EQ(rect.GetWidth(), 15.5f);
   EXPECT_EQ(rect.GetHeight(), 15.125f);
   EXPECT_FALSE(rect.IsEmpty());
   EXPECT_TRUE(rect.IsFinite());
 }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [373/523]

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

Definition at line 1358 of file rect_unittests.cc.

                           {
   auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
     ASSERT_TRUE(a.IsFinite()) << label;
     ASSERT_TRUE(b.IsFinite()) << label;
     ASSERT_FALSE(a.Union(b).IsEmpty());
  
     for (int i = 1; i < 16; i++) {
       // NaN in a produces b
       EXPECT_EQ(swap_nan(a, i).Union(b), b) << label << ", index = " << i;
       // NaN in b produces a
       EXPECT_EQ(a.Union(swap_nan(b, i)), a) << label << ", index = " << i;
       // NaN in both is empty
       for (int j = 1; j < 16; j++) {
         EXPECT_TRUE(swap_nan(a, i).Union(swap_nan(b, j)).IsEmpty())
             << label << ", indices = " << i << ", " << j;
       }
     }
   };
  
   auto check_empty_flips = [](const Rect& a, const Rect& b,
                               const std::string& label) {
     ASSERT_FALSE(a.IsEmpty());
     // b is allowed to be empty
  
     // unflipped a vs flipped (empty) b yields a
     EXPECT_EQ(a.Union(flip_lr(b)), a) << label;
     EXPECT_EQ(a.Union(flip_tb(b)), a) << label;
     EXPECT_EQ(a.Union(flip_lrtb(b)), a) << label;
  
     // flipped (empty) a vs unflipped b yields b
     EXPECT_EQ(flip_lr(a).Union(b), b) << label;
     EXPECT_EQ(flip_tb(a).Union(b), b) << label;
     EXPECT_EQ(flip_lrtb(a).Union(b), b) << label;
  
     // flipped (empty) a vs flipped (empty) b yields empty
     EXPECT_TRUE(flip_lr(a).Union(flip_lr(b)).IsEmpty()) << label;
     EXPECT_TRUE(flip_tb(a).Union(flip_tb(b)).IsEmpty()) << label;
     EXPECT_TRUE(flip_lrtb(a).Union(flip_lrtb(b)).IsEmpty()) << label;
   };
  
   auto test = [&check_nans, &check_empty_flips](const Rect& a, const Rect& b,
                                                 const Rect& result) {
     ASSERT_FALSE(a.IsEmpty()) << a;
     // b is allowed to be empty
  
     std::stringstream stream;
     stream << a << " union " << b;
     auto label = stream.str();
  
     EXPECT_EQ(a.Union(b), result) << label;
     EXPECT_EQ(b.Union(a), result) << label;
     check_empty_flips(a, b, label);
     check_nans(a, b, label);
   };
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(0, 0, 0, 0);
     auto expected = Rect::MakeXYWH(100, 100, 100, 100);
     test(a, b, expected);
   }
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(0, 0, 1, 1);
     auto expected = Rect::MakeXYWH(0, 0, 200, 200);
     test(a, b, expected);
   }
  
   {
     auto a = Rect::MakeXYWH(100, 100, 100, 100);
     auto b = Rect::MakeXYWH(10, 10, 1, 1);
     auto expected = Rect::MakeXYWH(10, 10, 190, 190);
     test(a, b, expected);
   }
  
   {
     auto a = Rect::MakeXYWH(0, 0, 100, 100);
     auto b = Rect::MakeXYWH(10, 10, 100, 100);
     auto expected = Rect::MakeXYWH(0, 0, 110, 110);
     test(a, b, expected);
   }
  
   {
     auto a = Rect::MakeXYWH(0, 0, 100, 100);
     auto b = Rect::MakeXYWH(100, 100, 100, 100);
     auto expected = Rect::MakeXYWH(0, 0, 200, 200);
     test(a, b, expected);
   }
 }

References impeller::saturated::b, flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::IsFinite(), impeller::TRect< Scalar >::MakeXYWH(), swap_nan(), and impeller::TRect< T >::Union().

◆ TEST() [374/523]

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

Definition at line 1172 of file rect_unittests.cc.

                                 {
   auto nan = std::numeric_limits<Scalar>::quiet_NaN();
  
   // Non-empty
   EXPECT_FALSE(Rect::MakeXYWH(1.5, 2.3, 10.5, 7.2).IsEmpty());
  
   // Empty both width and height both 0 or negative, in all combinations
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 0.0, 0.0).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, -1.0, -1.0).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 0.0, -1.0).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, -1.0, 0.0).IsEmpty());
  
   // Empty for 0 or negative width or height (but not both at the same time)
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 10.5, 0.0).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 10.5, -1.0).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 0.0, 7.2).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, -1.0, 7.2).IsEmpty());
  
   // Empty for NaN in width or height or both
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 10.5, nan).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, nan, 7.2).IsEmpty());
   EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, nan, nan).IsEmpty());
 }

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [375/523]

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

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

References EXPECT_RECT_NEAR, EXPECT_VECTOR3_NEAR, impeller::TRect< T >::GetLeftBottom(), impeller::TRect< T >::GetLeftTop(), impeller::TRect< T >::GetRightBottom(), impeller::TRect< T >::GetRightTop(), impeller::TRect< T >::IsEmpty(), impeller::Matrix::MakeColumn(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< T >::TransformAndClipBounds().

◆ TEST() [376/523]

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

Definition at line 133 of file render_pass_builder_vk_unittests.cc.

                                                             {
   RenderPassBuilderVK builder = RenderPassBuilderVK();
   auto const context = MockVulkanContextBuilder().Build();
  
   // Create an MSAA color attachment.
   builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                              SampleCount::kCount4, LoadAction::kClear,
                              StoreAction::kMultisampleResolve);
  
   auto render_pass = builder.Build(context->GetDevice());
  
   EXPECT_TRUE(!!render_pass);
  
   auto maybe_color = builder.GetColor0();
   ASSERT_TRUE(maybe_color.has_value());
   if (!maybe_color.has_value()) {
     return;
   }
   vk::AttachmentDescription color = maybe_color.value();
  
   // MSAA Texture.
   EXPECT_EQ(color.initialLayout, vk::ImageLayout::eUndefined);
   EXPECT_EQ(color.finalLayout, vk::ImageLayout::eGeneral);
   EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eClear);
   EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eDontCare);
  
   auto maybe_resolve = builder.GetColor0Resolve();
   ASSERT_TRUE(maybe_resolve.has_value());
   if (!maybe_resolve.has_value()) {
     return;
   }
   vk::AttachmentDescription resolve = maybe_resolve.value();
  
   // MSAA Resolve Texture.
   EXPECT_EQ(resolve.initialLayout, vk::ImageLayout::eUndefined);
   EXPECT_EQ(resolve.finalLayout, vk::ImageLayout::eShaderReadOnlyOptimal);
   EXPECT_EQ(resolve.loadOp, vk::AttachmentLoadOp::eClear);
   EXPECT_EQ(resolve.storeOp, vk::AttachmentStoreOp::eStore);
 }

References impeller::RenderPassBuilderVK::Build(), impeller::RenderPassBuilderVK::GetColor0(), impeller::RenderPassBuilderVK::GetColor0Resolve(), impeller::kClear, impeller::kCount4, impeller::kMultisampleResolve, impeller::kR8G8B8A8UNormInt, and impeller::RenderPassBuilderVK::SetColorAttachment().

◆ TEST() [377/523]

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

Definition at line 56 of file render_pass_builder_vk_unittests.cc.

                                                                    {
   RenderPassBuilderVK builder = RenderPassBuilderVK();
   auto const context = MockVulkanContextBuilder().Build();
  
   // Create a single color attachment with a transient depth stencil.
   builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                              SampleCount::kCount1, LoadAction::kClear,
                              StoreAction::kStore, vk::ImageLayout::eGeneral);
   builder.SetDepthStencilAttachment(PixelFormat::kD24UnormS8Uint,
                                     SampleCount::kCount1, LoadAction::kDontCare,
                                     StoreAction::kDontCare);
  
   auto render_pass = builder.Build(context->GetDevice());
  
   EXPECT_TRUE(!!render_pass);
  
   std::optional<vk::AttachmentDescription> maybe_color = builder.GetColor0();
   ASSERT_TRUE(maybe_color.has_value());
   if (!maybe_color.has_value()) {
     return;
   }
   vk::AttachmentDescription color = maybe_color.value();
  
   EXPECT_EQ(color.initialLayout, vk::ImageLayout::eUndefined);
   EXPECT_EQ(color.finalLayout, vk::ImageLayout::eShaderReadOnlyOptimal);
   EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eClear);
   EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eStore);
  
   std::optional<vk::AttachmentDescription> maybe_depth_stencil =
       builder.GetDepthStencil();
   ASSERT_TRUE(maybe_depth_stencil.has_value());
   if (!maybe_depth_stencil.has_value()) {
     return;
   }
   vk::AttachmentDescription depth_stencil = maybe_depth_stencil.value();
  
   EXPECT_EQ(depth_stencil.initialLayout, vk::ImageLayout::eUndefined);
   EXPECT_EQ(depth_stencil.finalLayout,
             vk::ImageLayout::eDepthStencilAttachmentOptimal);
   EXPECT_EQ(depth_stencil.loadOp, vk::AttachmentLoadOp::eDontCare);
   EXPECT_EQ(depth_stencil.storeOp, vk::AttachmentStoreOp::eDontCare);
   EXPECT_EQ(depth_stencil.stencilLoadOp, vk::AttachmentLoadOp::eDontCare);
   EXPECT_EQ(depth_stencil.stencilStoreOp, vk::AttachmentStoreOp::eDontCare);
 }

References impeller::RenderPassBuilderVK::Build(), impeller::RenderPassBuilderVK::GetColor0(), impeller::RenderPassBuilderVK::GetDepthStencil(), impeller::kClear, impeller::kCount1, impeller::kD24UnormS8Uint, impeller::kDontCare, impeller::kR8G8B8A8UNormInt, impeller::kStore, impeller::RenderPassBuilderVK::SetColorAttachment(), and impeller::RenderPassBuilderVK::SetDepthStencilAttachment().

◆ TEST() [378/523]

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

Definition at line 15 of file render_pass_builder_vk_unittests.cc.

                                                              {
   RenderPassBuilderVK builder = RenderPassBuilderVK();
   auto const context = MockVulkanContextBuilder().Build();
  
   // Create a single color attachment with a transient depth stencil.
   builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                              SampleCount::kCount1, LoadAction::kClear,
                              StoreAction::kStore);
  
   auto render_pass = builder.Build(context->GetDevice());
  
   EXPECT_TRUE(!!render_pass);
   EXPECT_FALSE(builder.GetDepthStencil().has_value());
 }

References impeller::RenderPassBuilderVK::Build(), impeller::RenderPassBuilderVK::GetDepthStencil(), impeller::kClear, impeller::kCount1, impeller::kR8G8B8A8UNormInt, impeller::kStore, and impeller::RenderPassBuilderVK::SetColorAttachment().

◆ TEST() [379/523]

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

Definition at line 101 of file render_pass_builder_vk_unittests.cc.

                                                           {
   RenderPassBuilderVK builder = RenderPassBuilderVK();
   auto const context = MockVulkanContextBuilder().Build();
  
   // Create a single color attachment with a transient depth stencil.
   builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                              SampleCount::kCount1, LoadAction::kClear,
                              StoreAction::kStore);
   builder.SetStencilAttachment(PixelFormat::kS8UInt, SampleCount::kCount1,
                                LoadAction::kDontCare, StoreAction::kDontCare);
  
   auto render_pass = builder.Build(context->GetDevice());
  
   EXPECT_TRUE(!!render_pass);
  
   std::optional<vk::AttachmentDescription> maybe_depth_stencil =
       builder.GetDepthStencil();
   ASSERT_TRUE(maybe_depth_stencil.has_value());
   if (!maybe_depth_stencil.has_value()) {
     return;
   }
   vk::AttachmentDescription depth_stencil = maybe_depth_stencil.value();
  
   EXPECT_EQ(depth_stencil.initialLayout, vk::ImageLayout::eUndefined);
   EXPECT_EQ(depth_stencil.finalLayout,
             vk::ImageLayout::eDepthStencilAttachmentOptimal);
   EXPECT_EQ(depth_stencil.loadOp, vk::AttachmentLoadOp::eDontCare);
   EXPECT_EQ(depth_stencil.storeOp, vk::AttachmentStoreOp::eDontCare);
   EXPECT_EQ(depth_stencil.stencilLoadOp, vk::AttachmentLoadOp::eDontCare);
   EXPECT_EQ(depth_stencil.stencilStoreOp, vk::AttachmentStoreOp::eDontCare);
 }

References impeller::RenderPassBuilderVK::Build(), impeller::RenderPassBuilderVK::GetDepthStencil(), impeller::kClear, impeller::kCount1, impeller::kDontCare, impeller::kR8G8B8A8UNormInt, impeller::kS8UInt, impeller::kStore, impeller::RenderPassBuilderVK::SetColorAttachment(), and impeller::RenderPassBuilderVK::SetStencilAttachment().

◆ TEST() [380/523]

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

Definition at line 30 of file render_pass_builder_vk_unittests.cc.

                                                                {
   RenderPassBuilderVK builder = RenderPassBuilderVK();
   auto const context = MockVulkanContextBuilder().Build();
  
   builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                              SampleCount::kCount1, LoadAction::kLoad,
                              StoreAction::kStore,
                              vk::ImageLayout::eColorAttachmentOptimal);
  
   auto render_pass = builder.Build(context->GetDevice());
  
   EXPECT_TRUE(!!render_pass);
  
   std::optional<vk::AttachmentDescription> maybe_color = builder.GetColor0();
   ASSERT_TRUE(maybe_color.has_value());
   if (!maybe_color.has_value()) {
     return;
   }
   vk::AttachmentDescription color = maybe_color.value();
  
   EXPECT_EQ(color.initialLayout, vk::ImageLayout::eColorAttachmentOptimal);
   EXPECT_EQ(color.finalLayout, vk::ImageLayout::eShaderReadOnlyOptimal);
   EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eLoad);
   EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eStore);
 }

References impeller::RenderPassBuilderVK::Build(), impeller::RenderPassBuilderVK::GetColor0(), impeller::kCount1, impeller::kLoad, impeller::kR8G8B8A8UNormInt, impeller::kStore, and impeller::RenderPassBuilderVK::SetColorAttachment().

◆ TEST() [381/523]

impeller::testing::TEST	(	RenderPassVK	,
		DoesNotRedundantlySetStencil
	)

Definition at line 17 of file render_pass_vk_unittests.cc.

                                                  {
   std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
   std::shared_ptr<Context> copy = context;
   auto cmd_buffer = context->CreateCommandBuffer();
  
   RenderTargetAllocator allocator(context->GetResourceAllocator());
   RenderTarget target = allocator.CreateOffscreenMSAA(*copy.get(), {1, 1}, 1);
  
   std::shared_ptr<RenderPass> render_pass =
       cmd_buffer->CreateRenderPass(target);
  
   // Stencil reference set once at buffer start.
   auto called_functions = GetMockVulkanFunctions(context->GetDevice());
   EXPECT_EQ(std::count(called_functions->begin(), called_functions->end(),
                        "vkCmdSetStencilReference"),
             1);
  
   // Duplicate stencil ref is not replaced.
   render_pass->SetStencilReference(0);
   render_pass->SetStencilReference(0);
   render_pass->SetStencilReference(0);
  
   called_functions = GetMockVulkanFunctions(context->GetDevice());
   EXPECT_EQ(std::count(called_functions->begin(), called_functions->end(),
                        "vkCmdSetStencilReference"),
             1);
  
   // Different stencil value is updated.
   render_pass->SetStencilReference(1);
   called_functions = GetMockVulkanFunctions(context->GetDevice());
   EXPECT_EQ(std::count(called_functions->begin(), called_functions->end(),
                        "vkCmdSetStencilReference"),
             2);
 }

References impeller::RenderTargetAllocator::CreateOffscreenMSAA().

◆ TEST() [382/523]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		CreatesANewInstance
	)

Definition at line 18 of file resource_manager_vk_unittests.cc.

                                                  {
   auto const a = ResourceManagerVK::Create();
   auto const b = ResourceManagerVK::Create();
   EXPECT_NE(a, b);
 }

References impeller::saturated::b, and impeller::ResourceManagerVK::Create().

◆ TEST() [383/523]

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

Definition at line 58 of file resource_manager_vk_unittests.cc.

                                           {
   // In a typical app, there is a single ResourceManagerVK per app, shared b/w
   // threads.
   //
   // This test ensures that the ResourceManagerVK is thread-safe.
   std::weak_ptr<ResourceManagerVK> manager;
  
   {
     auto const manager = ResourceManagerVK::Create();
  
     // Spawn two threads, and have them both put resources into the manager.
     struct MockResource {};
  
     std::thread thread1([&manager]() {
       UniqueResourceVKT<MockResource>(manager, MockResource{});
     });
  
     std::thread thread2([&manager]() {
       UniqueResourceVKT<MockResource>(manager, MockResource{});
     });
  
     thread1.join();
     thread2.join();
   }
  
   // The thread should have terminated.
   EXPECT_EQ(manager.lock(), nullptr);
 }

References impeller::ResourceManagerVK::Create().

◆ TEST() [384/523]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		ReclaimMovesAResourceAndDestroysIt
	)

Definition at line 24 of file resource_manager_vk_unittests.cc.

                                                                 {
   auto const manager = ResourceManagerVK::Create();
  
   auto waiter = fml::AutoResetWaitableEvent();
   auto dead = false;
   auto rattle = fml::ScopedCleanupClosure([&waiter]() { waiter.Signal(); });
  
   // Not killed immediately.
   EXPECT_FALSE(waiter.IsSignaledForTest());
  
   {
     auto resource = UniqueResourceVKT<fml::ScopedCleanupClosure>(
         manager, std::move(rattle));
   }
  
   waiter.Wait();
 }

References impeller::ResourceManagerVK::Create().

◆ TEST() [385/523]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		TerminatesWhenOutOfScope
	)

Definition at line 43 of file resource_manager_vk_unittests.cc.

                                                       {
   // Originally, this shared_ptr was never destroyed, and the thread never
   // terminated. This test ensures that the thread terminates when the
   // ResourceManagerVK is out of scope.
   std::weak_ptr<ResourceManagerVK> manager;
  
   {
     auto shared = ResourceManagerVK::Create();
     manager = shared;
   }
  
   // The thread should have terminated.
   EXPECT_EQ(manager.lock(), nullptr);
 }

References impeller::ResourceManagerVK::Create().

◆ TEST() [386/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiCornersSameTolerance
	)

Definition at line 268 of file rounding_radii_unittests.cc.

                                                           {
   RoundingRadii radii{
       .top_left = {10, 20},
       .top_right = {10.01, 20.01},
       .bottom_left = {9.99, 19.99},
       .bottom_right = {9.99, 20.01},
   };
  
   EXPECT_TRUE(radii.AreAllCornersSame(.02));
  
   {
     RoundingRadii different = radii;
     different.top_left.width = 10.03;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.top_left.height = 20.03;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.top_right.width = 10.03;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.top_right.height = 20.03;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.bottom_left.width = 9.97;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.bottom_left.height = 19.97;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.bottom_right.width = 9.97;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
   {
     RoundingRadii different = radii;
     different.bottom_right.height = 20.03;
     EXPECT_FALSE(different.AreAllCornersSame(.02));
   }
 }

References impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::TSize< T >::height, impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and impeller::TSize< T >::width.

◆ TEST() [387/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiDefaultConstructor
	)

Definition at line 34 of file rounding_radii_unittests.cc.

                                                         {
   RoundingRadii radii = RoundingRadii();
  
   EXPECT_TRUE(radii.AreAllCornersEmpty());
   EXPECT_TRUE(radii.AreAllCornersSame());
   EXPECT_TRUE(radii.IsFinite());
   EXPECT_EQ(radii.top_left, Size());
   EXPECT_EQ(radii.top_right, Size());
   EXPECT_EQ(radii.bottom_left, Size());
   EXPECT_EQ(radii.bottom_right, Size());
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [388/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEmptyDeclaration
	)

Definition at line 14 of file rounding_radii_unittests.cc.

                                                       {
   RoundingRadii radii;
  
   EXPECT_TRUE(radii.AreAllCornersEmpty());
   EXPECT_TRUE(radii.AreAllCornersSame());
   EXPECT_TRUE(radii.IsFinite());
   EXPECT_EQ(radii.top_left, Size());
   EXPECT_EQ(radii.top_right, Size());
   EXPECT_EQ(radii.bottom_left, Size());
   EXPECT_EQ(radii.bottom_right, Size());
   EXPECT_EQ(radii.top_left.width, 0.0f);
   EXPECT_EQ(radii.top_left.height, 0.0f);
   EXPECT_EQ(radii.top_right.width, 0.0f);
   EXPECT_EQ(radii.top_right.height, 0.0f);
   EXPECT_EQ(radii.bottom_left.width, 0.0f);
   EXPECT_EQ(radii.bottom_left.height, 0.0f);
   EXPECT_EQ(radii.bottom_right.width, 0.0f);
   EXPECT_EQ(radii.bottom_right.height, 0.0f);
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::TSize< T >::height, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and impeller::TSize< T >::width.

◆ TEST() [389/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEmptyScalarConstructor
	)

Definition at line 58 of file rounding_radii_unittests.cc.

                                                             {
   RoundingRadii radii = RoundingRadii::MakeRadius(-5.0f);
  
   EXPECT_TRUE(radii.AreAllCornersEmpty());
   EXPECT_TRUE(radii.AreAllCornersSame());
   EXPECT_TRUE(radii.IsFinite());
   EXPECT_EQ(radii.top_left, Size(-5.0f, -5.0f));
   EXPECT_EQ(radii.top_right, Size(-5.0f, -5.0f));
   EXPECT_EQ(radii.bottom_left, Size(-5.0f, -5.0f));
   EXPECT_EQ(radii.bottom_right, Size(-5.0f, -5.0f));
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [390/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEmptySizeConstructor
	)

Definition at line 82 of file rounding_radii_unittests.cc.

                                                           {
   {
     RoundingRadii radii = RoundingRadii::MakeRadii(Size(-5.0f, 6.0f));
  
     EXPECT_TRUE(radii.AreAllCornersEmpty());
     EXPECT_TRUE(radii.AreAllCornersSame());
     EXPECT_TRUE(radii.IsFinite());
     EXPECT_EQ(radii.top_left, Size(-5.0f, 6.0f));
     EXPECT_EQ(radii.top_right, Size(-5.0f, 6.0f));
     EXPECT_EQ(radii.bottom_left, Size(-5.0f, 6.0f));
     EXPECT_EQ(radii.bottom_right, Size(-5.0f, 6.0f));
   }
  
   {
     RoundingRadii radii = RoundingRadii::MakeRadii(Size(5.0f, -6.0f));
  
     EXPECT_TRUE(radii.AreAllCornersEmpty());
     EXPECT_TRUE(radii.AreAllCornersSame());
     EXPECT_TRUE(radii.IsFinite());
     EXPECT_EQ(radii.top_left, Size(5.0f, -6.0f));
     EXPECT_EQ(radii.top_right, Size(5.0f, -6.0f));
     EXPECT_EQ(radii.bottom_left, Size(5.0f, -6.0f));
     EXPECT_EQ(radii.bottom_right, Size(5.0f, -6.0f));
   }
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [391/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEquals
	)

Definition at line 201 of file rounding_radii_unittests.cc.

                                             {
   RoundingRadii radii = {
       .top_left = Size(5.0f, 5.5f),
       .top_right = Size(6.0f, 6.5f),
       .bottom_left = Size(7.0f, 7.5f),
       .bottom_right = Size(8.0f, 8.5f),
   };
   RoundingRadii other = {
       .top_left = Size(5.0f, 5.5f),
       .top_right = Size(6.0f, 6.5f),
       .bottom_left = Size(7.0f, 7.5f),
       .bottom_right = Size(8.0f, 8.5f),
   };
  
   EXPECT_EQ(radii, other);
 }

References impeller::RoundingRadii::top_left.

◆ TEST() [392/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiMultiply
	)

Definition at line 183 of file rounding_radii_unittests.cc.

                                               {
   RoundingRadii radii = {
       .top_left = Size(5.0f, 5.5f),
       .top_right = Size(6.0f, 6.5f),
       .bottom_left = Size(7.0f, 7.5f),
       .bottom_right = Size(8.0f, 8.5f),
   };
   RoundingRadii doubled = radii * 2.0f;
  
   EXPECT_FALSE(doubled.AreAllCornersEmpty());
   EXPECT_FALSE(doubled.AreAllCornersSame());
   EXPECT_TRUE(doubled.IsFinite());
   EXPECT_EQ(doubled.top_left, Size(10.0f, 11.0f));
   EXPECT_EQ(doubled.top_right, Size(12.0f, 13.0f));
   EXPECT_EQ(doubled.bottom_left, Size(14.0f, 15.0f));
   EXPECT_EQ(doubled.bottom_right, Size(16.0f, 17.0f));
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [393/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiNamedSizesConstructor
	)

Definition at line 108 of file rounding_radii_unittests.cc.

                                                            {
   RoundingRadii radii = {
       .top_left = Size(5.0f, 5.5f),
       .top_right = Size(6.0f, 6.5f),
       .bottom_left = Size(7.0f, 7.5f),
       .bottom_right = Size(8.0f, 8.5f),
   };
  
   EXPECT_FALSE(radii.AreAllCornersEmpty());
   EXPECT_FALSE(radii.AreAllCornersSame());
   EXPECT_TRUE(radii.IsFinite());
   EXPECT_EQ(radii.top_left, Size(5.0f, 5.5f));
   EXPECT_EQ(radii.top_right, Size(6.0f, 6.5f));
   EXPECT_EQ(radii.bottom_left, Size(7.0f, 7.5f));
   EXPECT_EQ(radii.bottom_right, Size(8.0f, 8.5f));
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [394/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiNotEquals
	)

Definition at line 218 of file rounding_radii_unittests.cc.

                                                {
   const RoundingRadii radii = {
       .top_left = Size(5.0f, 5.5f),
       .top_right = Size(6.0f, 6.5f),
       .bottom_left = Size(7.0f, 7.5f),
       .bottom_right = Size(8.0f, 8.5f),
   };
  
   {
     RoundingRadii different = radii;
     different.top_left.width = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.top_left.height = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.top_right.width = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.top_right.height = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.bottom_left.width = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.bottom_left.height = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.bottom_right.width = 100.0f;
     EXPECT_NE(different, radii);
   }
   {
     RoundingRadii different = radii;
     different.bottom_right.height = 100.0f;
     EXPECT_NE(different, radii);
   }
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::TSize< T >::height, impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and impeller::TSize< T >::width.

◆ TEST() [395/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiPartialNamedSizesConstructor
	)

Definition at line 125 of file rounding_radii_unittests.cc.

                                                                   {
   {
     RoundingRadii radii = {
         .top_left = Size(5.0f, 5.5f),
     };
  
     EXPECT_FALSE(radii.AreAllCornersEmpty());
     EXPECT_FALSE(radii.AreAllCornersSame());
     EXPECT_TRUE(radii.IsFinite());
     EXPECT_EQ(radii.top_left, Size(5.0f, 5.5f));
     EXPECT_EQ(radii.top_right, Size());
     EXPECT_EQ(radii.bottom_left, Size());
     EXPECT_EQ(radii.bottom_right, Size());
   }
  
   {
     RoundingRadii radii = {
         .top_right = Size(6.0f, 6.5f),
     };
  
     EXPECT_FALSE(radii.AreAllCornersEmpty());
     EXPECT_FALSE(radii.AreAllCornersSame());
     EXPECT_TRUE(radii.IsFinite());
     EXPECT_EQ(radii.top_left, Size());
     EXPECT_EQ(radii.top_right, Size(6.0f, 6.5f));
     EXPECT_EQ(radii.bottom_left, Size());
     EXPECT_EQ(radii.bottom_right, Size());
   }
  
   {
     RoundingRadii radii = {
         .bottom_left = Size(7.0f, 7.5f),
     };
  
     EXPECT_FALSE(radii.AreAllCornersEmpty());
     EXPECT_FALSE(radii.AreAllCornersSame());
     EXPECT_TRUE(radii.IsFinite());
     EXPECT_EQ(radii.top_left, Size());
     EXPECT_EQ(radii.top_right, Size());
     EXPECT_EQ(radii.bottom_left, Size(7.0f, 7.5f));
     EXPECT_EQ(radii.bottom_right, Size());
   }
  
   {
     RoundingRadii radii = {
         .bottom_right = Size(8.0f, 8.5f),
     };
  
     EXPECT_FALSE(radii.AreAllCornersEmpty());
     EXPECT_FALSE(radii.AreAllCornersSame());
     EXPECT_TRUE(radii.IsFinite());
     EXPECT_EQ(radii.top_left, Size());
     EXPECT_EQ(radii.top_right, Size());
     EXPECT_EQ(radii.bottom_left, Size());
     EXPECT_EQ(radii.bottom_right, Size(8.0f, 8.5f));
   }
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [396/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiScalarConstructor
	)

Definition at line 46 of file rounding_radii_unittests.cc.

                                                        {
   RoundingRadii radii = RoundingRadii::MakeRadius(5.0f);
  
   EXPECT_FALSE(radii.AreAllCornersEmpty());
   EXPECT_TRUE(radii.AreAllCornersSame());
   EXPECT_TRUE(radii.IsFinite());
   EXPECT_EQ(radii.top_left, Size(5.0f, 5.0f));
   EXPECT_EQ(radii.top_right, Size(5.0f, 5.0f));
   EXPECT_EQ(radii.bottom_left, Size(5.0f, 5.0f));
   EXPECT_EQ(radii.bottom_right, Size(5.0f, 5.0f));
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [397/523]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiSizeConstructor
	)

Definition at line 70 of file rounding_radii_unittests.cc.

                                                      {
   RoundingRadii radii = RoundingRadii::MakeRadii(Size(5.0f, 6.0f));
  
   EXPECT_FALSE(radii.AreAllCornersEmpty());
   EXPECT_TRUE(radii.AreAllCornersSame());
   EXPECT_TRUE(radii.IsFinite());
   EXPECT_EQ(radii.top_left, Size(5.0f, 6.0f));
   EXPECT_EQ(radii.top_right, Size(5.0f, 6.0f));
   EXPECT_EQ(radii.bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(radii.bottom_right, Size(5.0f, 6.0f));
 }

References impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [398/523]

impeller::testing::TEST	(	RoundRectTest	,
		ContractAndRequireRadiiAdjustment
	)

Definition at line 496 of file round_rect_unittests.cc.

                                                        {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(-12.0);
   // Largest sum of paired radii sizes are the bottom and right edges
   // both of which sum to 12
   // Rect was 30x30 reduced by 12 on all sides leaving only 6x6, so all
   // radii are scaled by half to avoid overflowing the contracted rect
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(22.0f, 22.0f, 28.0f, 28.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(0.5f, 1.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(1.5f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(2.5f, 3.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(3.5f, 4.0f));
  
   // In this test, the MakeRectRadii constructor will make the same
   // adjustment to the radii that the Expand method applied.
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(22.0f, 22.0f, 6.0f, 6.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
  
   // In this test, the arguments to the constructor supply the correctly
   // adjusted radii (though there is no real way to tell other than
   // the result is the same).
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(22.0f, 22.0f, 6.0f, 6.0f),
                                      {
                                          .top_left = Size(0.5f, 1.0f),
                                          .top_right = Size(1.5f, 2.0f),
                                          .bottom_left = Size(2.5f, 3.0f),
                                          .bottom_right = Size(3.5f, 4.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [399/523]

impeller::testing::TEST	(	RoundRectTest	,
		ContractFourScalars
	)

Definition at line 464 of file round_rect_unittests.cc.

                                          {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(-1.0, -1.5, -2.0, -2.5);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(11.0f, 11.5f, 38.0f, 37.5f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(11.0f, 11.5f, 27.0f, 26.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [400/523]

impeller::testing::TEST	(	RoundRectTest	,
		ContractScalar
	)

Definition at line 400 of file round_rect_unittests.cc.

                                     {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(-2.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(12.0f, 12.0f, 38.0f, 38.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(12.0f, 12.0f, 26.0f, 26.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [401/523]

impeller::testing::TEST	(	RoundRectTest	,
		ContractTwoScalars
	)

Definition at line 432 of file round_rect_unittests.cc.

                                         {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(-1.0, -2.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(11.0f, 12.0f, 39.0f, 38.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(11.0f, 12.0f, 28.0f, 26.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [402/523]

impeller::testing::TEST	(	RoundRectTest	,
		DefaultConstructor
	)

Definition at line 41 of file round_rect_unittests.cc.

                                         {
   RoundRect round_rect = RoundRect();
  
   EXPECT_TRUE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect());
   EXPECT_EQ(round_rect.GetRadii().top_left, Size());
   EXPECT_EQ(round_rect.GetRadii().top_right, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [403/523]

impeller::testing::TEST	(	RoundRectTest	,
		DifferingCornersRoundRectContains
	)

Definition at line 652 of file round_rect_unittests.cc.

                                                        {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   auto round_rect =
       RoundRect::MakeRectRadii(bounds, {
                                            .top_left = Size(2.0, 3.0),
                                            .top_right = Size(4.0, 5.0),
                                            .bottom_left = Size(6.0, 7.0),
                                            .bottom_right = Size(8.0, 9.0),
                                        });
  
   // For a corner with radii {A, B}, the "45 degree point" on the
   // corner curve will be at an offset of:
   //
   // (A * sqrt(2) / 2, B * sqrt(2) / 2)
   //
   // And the center(s) of these corners are at:
   //
   // (+/-(50 - A), +/-(50 - B))
   auto coord = [](Scalar radius) {
     return 50 - radius + radius * kSqrt2 / 2.0f - kEhCloseEnough;
   };
   auto coord_in = [&coord](Scalar radius) {
     return coord(radius) - kEhCloseEnough;
   };
   auto coord_out = [&coord](Scalar radius) {
     // For some reason 1 kEhCloseEnough is not enough to put us outside
     // in some of the cases, so we use 2x the epsilon.
     return coord(radius) + 2 * kEhCloseEnough;
   };
   // Upper left corner (radii = {2.0, 3.0})
   EXPECT_TRUE(round_rect.Contains({-coord_in(2.0), -coord_in(3.0)}));
   EXPECT_FALSE(round_rect.Contains({-coord_out(2.0), -coord_out(3.0)}));
   // Upper right corner (radii = {4.0, 5.0})
   EXPECT_TRUE(round_rect.Contains({coord_in(4.0), -coord_in(5.0)}));
   EXPECT_FALSE(round_rect.Contains({coord_out(4.0), -coord_out(5.0)}));
   // Lower left corner (radii = {6.0, 7.0})
   EXPECT_TRUE(round_rect.Contains({-coord_in(6.0), coord_in(7.0)}));
   EXPECT_FALSE(round_rect.Contains({-coord_out(6.0), coord_out(7.0)}));
   // Lower right corner (radii = {8.0, 9.0})
   EXPECT_TRUE(round_rect.Contains({coord_in(8.0), coord_in(9.0)}));
   EXPECT_FALSE(round_rect.Contains({coord_out(8.0), coord_out(9.0)}));
 }

References impeller::kEhCloseEnough, impeller::kSqrt2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectRadii().

◆ TEST() [404/523]

impeller::testing::TEST	(	RoundRectTest	,
		EmptyDeclaration
	)

Definition at line 14 of file round_rect_unittests.cc.

                                       {
   RoundRect round_rect;
  
   EXPECT_TRUE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect());
   EXPECT_EQ(round_rect.GetBounds().GetLeft(), 0.0f);
   EXPECT_EQ(round_rect.GetBounds().GetTop(), 0.0f);
   EXPECT_EQ(round_rect.GetBounds().GetRight(), 0.0f);
   EXPECT_EQ(round_rect.GetBounds().GetBottom(), 0.0f);
   EXPECT_EQ(round_rect.GetRadii().top_left, Size());
   EXPECT_EQ(round_rect.GetRadii().top_right, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
   EXPECT_EQ(round_rect.GetRadii().top_left.width, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().top_left.height, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().top_right.width, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().top_right.height, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().bottom_left.width, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().bottom_left.height, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().bottom_right.width, 0.0f);
   EXPECT_EQ(round_rect.GetRadii().bottom_right.height, 0.0f);
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::TRect< T >::GetBottom(), impeller::RoundRect::GetBounds(), impeller::TRect< T >::GetLeft(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TSize< T >::height, impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and impeller::TSize< T >::width.

◆ TEST() [405/523]

impeller::testing::TEST	(	RoundRectTest	,
		EmptyOvalConstruction
	)

Definition at line 104 of file round_rect_unittests.cc.

                                            {
   RoundRect round_rect = RoundRect::MakeRectXY(
       Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f), 10.0f, 10.0f);
  
   EXPECT_TRUE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size());
   EXPECT_EQ(round_rect.GetRadii().top_right, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [406/523]

impeller::testing::TEST	(	RoundRectTest	,
		EmptyRectConstruction
	)

Definition at line 56 of file round_rect_unittests.cc.

                                            {
   RoundRect round_rect =
       RoundRect::MakeRect(Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
  
   EXPECT_TRUE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size());
   EXPECT_EQ(round_rect.GetRadii().top_right, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [407/523]

impeller::testing::TEST	(	RoundRectTest	,
		ExpandFourScalars
	)

Definition at line 368 of file round_rect_unittests.cc.

                                        {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(5.0, 6.0, 7.0, 8.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 4.0f, 47.0f, 48.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(5.0f, 4.0f, 42.0f, 44.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [408/523]

impeller::testing::TEST	(	RoundRectTest	,
		ExpandScalar
	)

Definition at line 304 of file round_rect_unittests.cc.

                                   {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(5.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 5.0f, 45.0f, 45.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(5.0f, 5.0f, 40.0f, 40.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [409/523]

impeller::testing::TEST	(	RoundRectTest	,
		ExpandTwoScalars
	)

Definition at line 336 of file round_rect_unittests.cc.

                                       {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect expanded = round_rect.Expand(5.0, 6.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 4.0f, 45.0f, 46.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(5.0f, 4.0f, 40.0f, 42.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [410/523]

impeller::testing::TEST	(	RoundRectTest	,
		InvertedOvalConstruction
	)

Definition at line 136 of file round_rect_unittests.cc.

                                               {
   RoundRect round_rect = RoundRect::MakeRectXY(
       Rect::MakeLTRB(20.0f, 20.0f, 10.0f, 10.0f), 10.0f, 10.0f);
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_TRUE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(5.0f, 5.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(5.0f, 5.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(5.0f, 5.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(5.0f, 5.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [411/523]

impeller::testing::TEST	(	RoundRectTest	,
		InvertedRectConstruction
	)

Definition at line 88 of file round_rect_unittests.cc.

                                               {
   RoundRect round_rect =
       RoundRect::MakeRect(Rect::MakeLTRB(20.0f, 20.0f, 10.0f, 10.0f));
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_TRUE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size());
   EXPECT_EQ(round_rect.GetRadii().top_right, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [412/523]

impeller::testing::TEST	(	RoundRectTest	,
		NoCornerRoundRectContains
	)

Definition at line 546 of file round_rect_unittests.cc.

                                                {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   // RRect of bounds with no corners contains corners just barely
   auto no_corners = RoundRect::MakeRectXY(bounds, 0.0f, 0.0f);
  
   EXPECT_TRUE(no_corners.Contains({-50, -50}));
   // Rectangles have half-in, half-out containment so we need
   // to be careful about testing containment of right/bottom corners.
   EXPECT_TRUE(no_corners.Contains({-50, 49.99}));
   EXPECT_TRUE(no_corners.Contains({49.99, -50}));
   EXPECT_TRUE(no_corners.Contains({49.99, 49.99}));
   EXPECT_FALSE(no_corners.Contains({-50.01, -50}));
   EXPECT_FALSE(no_corners.Contains({-50, -50.01}));
   EXPECT_FALSE(no_corners.Contains({-50.01, 50}));
   EXPECT_FALSE(no_corners.Contains({-50, 50.01}));
   EXPECT_FALSE(no_corners.Contains({50.01, -50}));
   EXPECT_FALSE(no_corners.Contains({50, -50.01}));
   EXPECT_FALSE(no_corners.Contains({50.01, 50}));
   EXPECT_FALSE(no_corners.Contains({50, 50.01}));
 }

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

◆ TEST() [413/523]

impeller::testing::TEST	(	RoundRectTest	,
		OvalConstructor
	)

Definition at line 120 of file round_rect_unittests.cc.

                                      {
   RoundRect round_rect =
       RoundRect::MakeOval(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_TRUE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(5.0f, 5.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(5.0f, 5.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(5.0f, 5.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(5.0f, 5.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeOval(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [414/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectConstructor
	)

Definition at line 72 of file round_rect_unittests.cc.

                                      {
   RoundRect round_rect =
       RoundRect::MakeRect(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_TRUE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size());
   EXPECT_EQ(round_rect.GetRadii().top_right, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [415/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiiConstructor
	)

Definition at line 200 of file round_rect_unittests.cc.

                                           {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),
                                {
                                    .top_left = Size(1.0, 1.5),
                                    .top_right = Size(2.0, 2.5f),
                                    .bottom_left = Size(3.0, 3.5f),
                                    .bottom_right = Size(4.0, 4.5f),
                                });
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(1.0f, 1.5f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 2.5f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(3.0f, 3.5f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(4.0f, 4.5f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [416/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiiOverflowHeightConstructor
	)

Definition at line 247 of file round_rect_unittests.cc.

                                                         {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 6.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   // Largest sum of paired radii heights is the right edge which sums to 12
   // Rect is only 6 tall so all radii are scaled by half
   // Rect is 30 wide so no scaling should happen due to radii widths
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 40.0f, 16.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(0.5f, 1.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(1.5f, 2.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.5f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(3.5f, 4.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [417/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiiOverflowWidthConstructor
	)

Definition at line 222 of file round_rect_unittests.cc.

                                                        {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 6.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   // Largest sum of paired radii widths is the bottom edge which sums to 12
   // Rect is only 6 wide so all radii are scaled by half
   // Rect is 30 tall so no scaling should happen due to radii heights
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 16.0f, 40.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(0.5f, 1.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(1.5f, 2.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.5f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(3.5f, 4.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [418/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiusConstructor
	)

Definition at line 152 of file round_rect_unittests.cc.

                                            {
   RoundRect round_rect = RoundRect::MakeRectRadius(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), 2.0f);
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(2.0f, 2.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 2.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.0f, 2.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(2.0f, 2.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [419/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectSizeConstructor
	)

Definition at line 184 of file round_rect_unittests.cc.

                                          {
   RoundRect round_rect = RoundRect::MakeRectXY(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), Size(2.0f, 3.0f));
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(2.0f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.0f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(2.0f, 3.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [420/523]

impeller::testing::TEST	(	RoundRectTest	,
		RectXYConstructor
	)

Definition at line 168 of file round_rect_unittests.cc.

                                        {
   RoundRect round_rect = RoundRect::MakeRectXY(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), 2.0f, 3.0f);
  
   EXPECT_FALSE(round_rect.IsEmpty());
   EXPECT_FALSE(round_rect.IsRect());
   EXPECT_FALSE(round_rect.IsOval());
   EXPECT_TRUE(round_rect.IsFinite());
   EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
   EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(round_rect.GetRadii().top_left, Size(2.0f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.0f, 3.0f));
   EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(2.0f, 3.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [421/523]

impeller::testing::TEST	(	RoundRectTest	,
		Shift
	)

Definition at line 272 of file round_rect_unittests.cc.

                            {
   RoundRect round_rect =
       RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                                {
                                    .top_left = Size(1.0f, 2.0f),
                                    .top_right = Size(3.0f, 4.0f),
                                    .bottom_left = Size(5.0f, 6.0f),
                                    .bottom_right = Size(7.0f, 8.0f),
                                });
   RoundRect shifted = round_rect.Shift(5.0, 6.0);
  
   EXPECT_FALSE(shifted.IsEmpty());
   EXPECT_FALSE(shifted.IsRect());
   EXPECT_FALSE(shifted.IsOval());
   EXPECT_TRUE(shifted.IsFinite());
   EXPECT_FALSE(shifted.GetBounds().IsEmpty());
   EXPECT_EQ(shifted.GetBounds(), Rect::MakeLTRB(15.0f, 16.0f, 45.0f, 46.0f));
   EXPECT_EQ(shifted.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(shifted.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(shifted.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(shifted.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(shifted,
             RoundRect::MakeRectRadii(Rect::MakeXYWH(15.0f, 16.0f, 30.0f, 30.0f),
                                      {
                                          .top_left = Size(1.0f, 2.0f),
                                          .top_right = Size(3.0f, 4.0f),
                                          .bottom_left = Size(5.0f, 6.0f),
                                          .bottom_right = Size(7.0f, 8.0f),
                                      }));
 }

References impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::RoundRect::Shift().

◆ TEST() [422/523]

impeller::testing::TEST	(	RoundRectTest	,
		TinyCornerRoundRectContains
	)

Definition at line 567 of file round_rect_unittests.cc.

                                                  {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   // RRect of bounds with even the tiniest corners does not contain corners
   auto tiny_corners = RoundRect::MakeRectXY(bounds, 0.01f, 0.01f);
  
   EXPECT_FALSE(tiny_corners.Contains({-50, -50}));
   EXPECT_FALSE(tiny_corners.Contains({-50, 50}));
   EXPECT_FALSE(tiny_corners.Contains({50, -50}));
   EXPECT_FALSE(tiny_corners.Contains({50, 50}));
 }

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

◆ TEST() [423/523]

impeller::testing::TEST	(	RoundRectTest	,
		UniformCircularRoundRectContains
	)

Definition at line 578 of file round_rect_unittests.cc.

                                                       {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   auto expanded_2_r_2 = RoundRect::MakeRectXY(bounds.Expand(2.0), 2.0f, 2.0f);
  
   // Expanded by 2.0 and then with a corner of 2.0 obviously still
   // contains the corners
   EXPECT_TRUE(expanded_2_r_2.Contains({-50, -50}));
   EXPECT_TRUE(expanded_2_r_2.Contains({-50, 50}));
   EXPECT_TRUE(expanded_2_r_2.Contains({50, -50}));
   EXPECT_TRUE(expanded_2_r_2.Contains({50, 50}));
  
   // Now we try to box in the corner containment to exactly where the
   // rounded corner of the expanded round rect with radii of 2.0 lies.
   // The 45-degree diagonal point of a circle of radius 2.0 lies at:
   //
   // (2 * sqrt(2) / 2, 2 * sqrt(2) / 2)
   // (sqrt(2), sqrt(2))
   //
   // So we test +/- (50 + sqrt(2) +/- epsilon)
   const auto coord_out = 50 + kSqrt2 + kEhCloseEnough;
   const auto coord_in = 50 + kSqrt2 - kEhCloseEnough;
   // Upper left corner
   EXPECT_TRUE(expanded_2_r_2.Contains({-coord_in, -coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({-coord_out, -coord_out}));
   // Upper right corner
   EXPECT_TRUE(expanded_2_r_2.Contains({coord_in, -coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({coord_out, -coord_out}));
   // Lower left corner
   EXPECT_TRUE(expanded_2_r_2.Contains({-coord_in, coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({-coord_out, coord_out}));
   // Lower right corner
   EXPECT_TRUE(expanded_2_r_2.Contains({coord_in, coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({coord_out, coord_out}));
 }

References impeller::TRect< T >::Expand(), impeller::kEhCloseEnough, impeller::kSqrt2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectXY().

◆ TEST() [424/523]

impeller::testing::TEST	(	RoundRectTest	,
		UniformEllipticalRoundRectContains
	)

Definition at line 613 of file round_rect_unittests.cc.

                                                         {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   auto expanded_2_r_2 = RoundRect::MakeRectXY(bounds.Expand(2.0), 2.0f, 3.0f);
  
   // Expanded by 2.0 and then with a corner of 2x3 should still
   // contain the corners
   EXPECT_TRUE(expanded_2_r_2.Contains({-50, -50}));
   EXPECT_TRUE(expanded_2_r_2.Contains({-50, 50}));
   EXPECT_TRUE(expanded_2_r_2.Contains({50, -50}));
   EXPECT_TRUE(expanded_2_r_2.Contains({50, 50}));
  
   // Now we try to box in the corner containment to exactly where the
   // rounded corner of the expanded round rect with radii of 2x3 lies.
   // The "45-degree diagonal point" of an ellipse of radii 2x3 lies at:
   //
   // (2 * sqrt(2) / 2, 3 * sqrt(2) / 2)
   // (sqrt(2), 3 * sqrt(2) / 2)
   //
   // And the center(s) of these corners are at:
   // (+/-(50 + 2 - 2), +/-(50 + 2 - 3))
   // = (+/-50, +/-49)
   const auto x_coord_out = 50 + kSqrt2 + kEhCloseEnough;
   const auto x_coord_in = 50 + kSqrt2 - kEhCloseEnough;
   const auto y_coord_out = 49 + 3 * kSqrt2 / 2 + kEhCloseEnough;
   const auto y_coord_in = 49 + 3 * kSqrt2 / 2 - kEhCloseEnough;
   // Upper left corner
   EXPECT_TRUE(expanded_2_r_2.Contains({-x_coord_in, -y_coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({-x_coord_out, -y_coord_out}));
   // Upper right corner
   EXPECT_TRUE(expanded_2_r_2.Contains({x_coord_in, -y_coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({x_coord_out, -y_coord_out}));
   // Lower left corner
   EXPECT_TRUE(expanded_2_r_2.Contains({-x_coord_in, y_coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({-x_coord_out, y_coord_out}));
   // Lower right corner
   EXPECT_TRUE(expanded_2_r_2.Contains({x_coord_in, y_coord_in}));
   EXPECT_FALSE(expanded_2_r_2.Contains({x_coord_out, y_coord_out}));
 }

References impeller::TRect< T >::Expand(), impeller::kEhCloseEnough, impeller::kSqrt2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectXY().

◆ TEST() [425/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ContractAndRequireRadiiAdjustment
	)

Definition at line 543 of file round_superellipse_unittests.cc.

                                                                {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(-12.0);
   // Largest sum of paired radii sizes are the bottom and right edges
   // both of which sum to 12
   // Rect was 30x30 reduced by 12 on all sides leaving only 6x6, so all
   // radii are scaled by half to avoid overflowing the contracted rect
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(22.0f, 22.0f, 28.0f, 28.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(0.5f, 1.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(1.5f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(2.5f, 3.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(3.5f, 4.0f));
  
   // In this test, the MakeRectRadii constructor will make the same
   // adjustment to the radii that the Expand method applied.
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(22.0f, 22.0f, 6.0f, 6.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
  
   // In this test, the arguments to the constructor supply the correctly
   // adjusted radii (though there is no real way to tell other than
   // the result is the same).
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(22.0f, 22.0f, 6.0f, 6.0f),
                           {
                               .top_left = Size(0.5f, 1.0f),
                               .top_right = Size(1.5f, 2.0f),
                               .bottom_left = Size(2.5f, 3.0f),
                               .bottom_right = Size(3.5f, 4.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [426/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ContractFourScalars
	)

Definition at line 511 of file round_superellipse_unittests.cc.

                                                  {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(-1.0, -1.5, -2.0, -2.5);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(11.0f, 11.5f, 38.0f, 37.5f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(11.0f, 11.5f, 27.0f, 26.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [427/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ContractScalar
	)

Definition at line 447 of file round_superellipse_unittests.cc.

                                             {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(-2.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(12.0f, 12.0f, 38.0f, 38.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(12.0f, 12.0f, 26.0f, 26.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [428/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ContractTwoScalars
	)

Definition at line 479 of file round_superellipse_unittests.cc.

                                                 {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(-1.0, -2.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(11.0f, 12.0f, 39.0f, 38.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(11.0f, 12.0f, 28.0f, 26.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [429/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		DefaultConstructor
	)

Definition at line 88 of file round_superellipse_unittests.cc.

                                                 {
   RoundSuperellipse rse = RoundSuperellipse();
  
   EXPECT_TRUE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_TRUE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect());
   EXPECT_EQ(rse.GetRadii().top_left, Size());
   EXPECT_EQ(rse.GetRadii().top_right, Size());
   EXPECT_EQ(rse.GetRadii().bottom_left, Size());
   EXPECT_EQ(rse.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [430/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		EmptyDeclaration
	)

Definition at line 61 of file round_superellipse_unittests.cc.

                                               {
   RoundSuperellipse rse;
  
   EXPECT_TRUE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_TRUE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect());
   EXPECT_EQ(rse.GetBounds().GetLeft(), 0.0f);
   EXPECT_EQ(rse.GetBounds().GetTop(), 0.0f);
   EXPECT_EQ(rse.GetBounds().GetRight(), 0.0f);
   EXPECT_EQ(rse.GetBounds().GetBottom(), 0.0f);
   EXPECT_EQ(rse.GetRadii().top_left, Size());
   EXPECT_EQ(rse.GetRadii().top_right, Size());
   EXPECT_EQ(rse.GetRadii().bottom_left, Size());
   EXPECT_EQ(rse.GetRadii().bottom_right, Size());
   EXPECT_EQ(rse.GetRadii().top_left.width, 0.0f);
   EXPECT_EQ(rse.GetRadii().top_left.height, 0.0f);
   EXPECT_EQ(rse.GetRadii().top_right.width, 0.0f);
   EXPECT_EQ(rse.GetRadii().top_right.height, 0.0f);
   EXPECT_EQ(rse.GetRadii().bottom_left.width, 0.0f);
   EXPECT_EQ(rse.GetRadii().bottom_left.height, 0.0f);
   EXPECT_EQ(rse.GetRadii().bottom_right.width, 0.0f);
   EXPECT_EQ(rse.GetRadii().bottom_right.height, 0.0f);
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::TRect< T >::GetBottom(), impeller::RoundSuperellipse::GetBounds(), impeller::TRect< T >::GetLeft(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TSize< T >::height, impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and impeller::TSize< T >::width.

◆ TEST() [431/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		EmptyOvalConstruction
	)

Definition at line 151 of file round_superellipse_unittests.cc.

                                                    {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectXY(
       Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f), 10.0f, 10.0f);
  
   EXPECT_TRUE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_TRUE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size());
   EXPECT_EQ(rse.GetRadii().top_right, Size());
   EXPECT_EQ(rse.GetRadii().bottom_left, Size());
   EXPECT_EQ(rse.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [432/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		EmptyRectConstruction
	)

Definition at line 103 of file round_superellipse_unittests.cc.

                                                    {
   RoundSuperellipse rse =
       RoundSuperellipse::MakeRect(Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
  
   EXPECT_TRUE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_TRUE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size());
   EXPECT_EQ(rse.GetRadii().top_right, Size());
   EXPECT_EQ(rse.GetRadii().bottom_left, Size());
   EXPECT_EQ(rse.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [433/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ExpandFourScalars
	)

Definition at line 415 of file round_superellipse_unittests.cc.

                                                {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(5.0, 6.0, 7.0, 8.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 4.0f, 47.0f, 48.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(5.0f, 4.0f, 42.0f, 44.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [434/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ExpandScalar
	)

Definition at line 351 of file round_superellipse_unittests.cc.

                                           {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(5.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 5.0f, 45.0f, 45.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(5.0f, 5.0f, 40.0f, 40.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [435/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		ExpandTwoScalars
	)

Definition at line 383 of file round_superellipse_unittests.cc.

                                               {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse expanded = rse.Expand(5.0, 6.0);
  
   EXPECT_FALSE(expanded.IsEmpty());
   EXPECT_FALSE(expanded.IsRect());
   EXPECT_FALSE(expanded.IsOval());
   EXPECT_TRUE(expanded.IsFinite());
   EXPECT_FALSE(expanded.GetBounds().IsEmpty());
   EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 4.0f, 45.0f, 46.0f));
   EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(expanded, RoundSuperellipse::MakeRectRadii(
                           Rect::MakeXYWH(5.0f, 4.0f, 40.0f, 42.0f),
                           {
                               .top_left = Size(1.0f, 2.0f),
                               .top_right = Size(3.0f, 4.0f),
                               .bottom_left = Size(5.0f, 6.0f),
                               .bottom_right = Size(7.0f, 8.0f),
                           }));
 }

References impeller::RoundSuperellipse::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [436/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		InvertedOvalConstruction
	)

Definition at line 183 of file round_superellipse_unittests.cc.

                                                       {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectXY(
       Rect::MakeLTRB(20.0f, 20.0f, 10.0f, 10.0f), 10.0f, 10.0f);
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_TRUE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(5.0f, 5.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(5.0f, 5.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(5.0f, 5.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(5.0f, 5.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [437/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		InvertedRectConstruction
	)

Definition at line 135 of file round_superellipse_unittests.cc.

                                                       {
   RoundSuperellipse rse =
       RoundSuperellipse::MakeRect(Rect::MakeLTRB(20.0f, 20.0f, 10.0f, 10.0f));
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_TRUE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size());
   EXPECT_EQ(rse.GetRadii().top_right, Size());
   EXPECT_EQ(rse.GetRadii().bottom_left, Size());
   EXPECT_EQ(rse.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [438/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		NoCornerRoundSuperellipseContains
	)

Definition at line 593 of file round_superellipse_unittests.cc.

                                                                {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   // Rounded superellipses of bounds with no corners contains corners just
   // barely.
   auto no_corners = RoundSuperellipse::MakeRectRadii(
       bounds, RoundingRadii::MakeRadii({0.0f, 0.0f}));
  
   EXPECT_TRUE(no_corners.Contains({-50, -50}));
   // Rectangles have half-in, half-out containment so we need
   // to be careful about testing containment of right/bottom corners.
   EXPECT_TRUE(no_corners.Contains({-50, 49.99}));
   EXPECT_TRUE(no_corners.Contains({49.99, -50}));
   EXPECT_TRUE(no_corners.Contains({49.99, 49.99}));
   EXPECT_FALSE(no_corners.Contains({-50.01, -50}));
   EXPECT_FALSE(no_corners.Contains({-50, -50.01}));
   EXPECT_FALSE(no_corners.Contains({-50.01, 50}));
   EXPECT_FALSE(no_corners.Contains({-50, 50.01}));
   EXPECT_FALSE(no_corners.Contains({50.01, -50}));
   EXPECT_FALSE(no_corners.Contains({50, -50.01}));
   EXPECT_FALSE(no_corners.Contains({50.01, 50}));
   EXPECT_FALSE(no_corners.Contains({50, 50.01}));
 }

References impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadii(), and impeller::RoundSuperellipse::MakeRectRadii().

◆ TEST() [439/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		OvalConstructor
	)

Definition at line 167 of file round_superellipse_unittests.cc.

                                              {
   RoundSuperellipse rse =
       RoundSuperellipse::MakeOval(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_TRUE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(5.0f, 5.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(5.0f, 5.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(5.0f, 5.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(5.0f, 5.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeOval(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [440/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		PathForRectangularRseWithShapeCornersShouldBeWithinBounds
	)

Definition at line 755 of file round_superellipse_unittests.cc.

                                                                 {
   Rect bounds = Rect::MakeLTRB(34.0f, 242.0f, 766.0f, 358.0f);
   // Regression test for https://github.com/flutter/flutter/issues/170593.
   // The issue was caused by incorrect calculation when building paths for
   // rounded superellipses with sharp corners and unequal width and height.
   // Since the most obvious symptom of the issue is some points being
   // incorrectly placed out of bounds, this test case simply verifies that all
   // points are within the bounds.
  
   auto rr = RoundSuperellipseParam::MakeBoundsRadii(
       bounds, {
                   .top_left = Size(14.0, 14.0),
                   .top_right = Size(14.0, 14.0),
                   .bottom_left = Size(0.0, 0.0),
                   .bottom_right = Size(0.0, 0.0),
               });
   SpyPathReceiver receiver;
   receiver.SpyLineTo(
       [&](const Point& p2) { EXPECT_TRUE(bounds.ContainsInclusive(p2)); });
   receiver.SpyCubicTo([&](const Point& cp1, const Point& cp2, const Point& p2) {
     EXPECT_TRUE(bounds.ContainsInclusive(p2));
   });
  
   rr.Dispatch(receiver);
 }

References impeller::TRect< T >::ContainsInclusive(), impeller::RoundSuperellipseParam::Dispatch(), impeller::RoundSuperellipseParam::MakeBoundsRadii(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [441/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		PointsOutsideOfSharpCorner
	)

Definition at line 738 of file round_superellipse_unittests.cc.

                                                         {
   Rect bounds = Rect::MakeLTRB(196.0f, 0.0f, 294.0f, 28.0f);
   // Regression test for a case where RoundSuperellipseParam::Contains
   // previously failed. Although the bounding rect filter of
   // `RoundSuperellipse::Contains` would reject this point, this test ensures
   // the internal logic of RoundSuperellipseParam::Contains is now correct.
   auto rr = RoundSuperellipseParam::MakeBoundsRadii(
       bounds, {
                   .top_left = Size(0.0, 0.0),
                   .top_right = Size(3.0, 3.0),
                   .bottom_left = Size(0.0, 0.0),
                   .bottom_right = Size(3.0, 3.0),
               });
  
   EXPECT_FALSE(rr.Contains(Point{147.0, 14.0}));
 }

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

◆ TEST() [442/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectConstructor
	)

Definition at line 119 of file round_superellipse_unittests.cc.

                                              {
   RoundSuperellipse rse =
       RoundSuperellipse::MakeRect(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_TRUE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size());
   EXPECT_EQ(rse.GetRadii().top_right, Size());
   EXPECT_EQ(rse.GetRadii().bottom_left, Size());
   EXPECT_EQ(rse.GetRadii().bottom_right, Size());
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [443/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectRadiiConstructor
	)

Definition at line 247 of file round_superellipse_unittests.cc.

                                                   {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),
       {
           .top_left = Size(1.0, 1.5),
           .top_right = Size(2.0, 2.5f),
           .bottom_left = Size(3.0, 3.5f),
           .bottom_right = Size(4.0, 4.5f),
       });
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(1.0f, 1.5f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(2.0f, 2.5f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(3.0f, 3.5f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(4.0f, 4.5f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [444/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectRadiiOverflowHeightConstructor
	)

Definition at line 294 of file round_superellipse_unittests.cc.

                                                                 {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 6.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   // Largest sum of paired radii heights is the right edge which sums to 12
   // Rect is only 6 tall so all radii are scaled by half
   // Rect is 30 wide so no scaling should happen due to radii widths
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 40.0f, 16.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(0.5f, 1.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(1.5f, 2.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(2.5f, 3.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(3.5f, 4.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [445/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectRadiiOverflowWidthConstructor
	)

Definition at line 269 of file round_superellipse_unittests.cc.

                                                                {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 6.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   // Largest sum of paired radii widths is the bottom edge which sums to 12
   // Rect is only 6 wide so all radii are scaled by half
   // Rect is 30 tall so no scaling should happen due to radii heights
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 16.0f, 40.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(0.5f, 1.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(1.5f, 2.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(2.5f, 3.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(3.5f, 4.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [446/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectRadiusConstructor
	)

Definition at line 199 of file round_superellipse_unittests.cc.

                                                    {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadius(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), 2.0f);
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(2.0f, 2.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(2.0f, 2.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(2.0f, 2.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(2.0f, 2.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [447/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectSizeConstructor
	)

Definition at line 231 of file round_superellipse_unittests.cc.

                                                  {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectXY(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), Size(2.0f, 3.0f));
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(2.0f, 3.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(2.0f, 3.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(2.0f, 3.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(2.0f, 3.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [448/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		RectXYConstructor
	)

Definition at line 215 of file round_superellipse_unittests.cc.

                                                {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectXY(
       Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), 2.0f, 3.0f);
  
   EXPECT_FALSE(rse.IsEmpty());
   EXPECT_FALSE(rse.IsRect());
   EXPECT_FALSE(rse.IsOval());
   EXPECT_TRUE(rse.IsFinite());
   EXPECT_FALSE(rse.GetBounds().IsEmpty());
   EXPECT_EQ(rse.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
   EXPECT_EQ(rse.GetRadii().top_left, Size(2.0f, 3.0f));
   EXPECT_EQ(rse.GetRadii().top_right, Size(2.0f, 3.0f));
   EXPECT_EQ(rse.GetRadii().bottom_left, Size(2.0f, 3.0f));
   EXPECT_EQ(rse.GetRadii().bottom_right, Size(2.0f, 3.0f));
 }

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::TRect< T >::IsEmpty(), impeller::RoundSuperellipse::IsEmpty(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [449/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		Shift
	)

Definition at line 319 of file round_superellipse_unittests.cc.

                                    {
   RoundSuperellipse rse = RoundSuperellipse::MakeRectRadii(
       Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
       {
           .top_left = Size(1.0f, 2.0f),
           .top_right = Size(3.0f, 4.0f),
           .bottom_left = Size(5.0f, 6.0f),
           .bottom_right = Size(7.0f, 8.0f),
       });
   RoundSuperellipse shifted = rse.Shift(5.0, 6.0);
  
   EXPECT_FALSE(shifted.IsEmpty());
   EXPECT_FALSE(shifted.IsRect());
   EXPECT_FALSE(shifted.IsOval());
   EXPECT_TRUE(shifted.IsFinite());
   EXPECT_FALSE(shifted.GetBounds().IsEmpty());
   EXPECT_EQ(shifted.GetBounds(), Rect::MakeLTRB(15.0f, 16.0f, 45.0f, 46.0f));
   EXPECT_EQ(shifted.GetRadii().top_left, Size(1.0f, 2.0f));
   EXPECT_EQ(shifted.GetRadii().top_right, Size(3.0f, 4.0f));
   EXPECT_EQ(shifted.GetRadii().bottom_left, Size(5.0f, 6.0f));
   EXPECT_EQ(shifted.GetRadii().bottom_right, Size(7.0f, 8.0f));
  
   EXPECT_EQ(shifted, RoundSuperellipse::MakeRectRadii(
                          Rect::MakeXYWH(15.0f, 16.0f, 30.0f, 30.0f),
                          {
                              .top_left = Size(1.0f, 2.0f),
                              .top_right = Size(3.0f, 4.0f),
                              .bottom_left = Size(5.0f, 6.0f),
                              .bottom_right = Size(7.0f, 8.0f),
                          }));
 }

References impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::RoundSuperellipse::Shift().

◆ TEST() [450/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		SlimDiagonalContains
	)

Definition at line 701 of file round_superellipse_unittests.cc.

                                                   {
   // This shape has large radii on one diagonal and tiny radii on the other,
   // resulting in a almond-like shape placed diagonally (NW to SE).
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   auto rr = RoundSuperellipse::MakeRectRadii(
       bounds, {
                   .top_left = Size(1.0, 1.0),
                   .top_right = Size(99.0, 99.0),
                   .bottom_left = Size(99.0, 99.0),
                   .bottom_right = Size(1.0, 1.0),
               });
  
   EXPECT_TRUE(rr.Contains(Point{0, 0}));
   EXPECT_FALSE(rr.Contains(Point{-49.999, -49.999}));
   EXPECT_FALSE(rr.Contains(Point{-49.999, 49.999}));
   EXPECT_FALSE(rr.Contains(Point{49.999, 49.999}));
   EXPECT_FALSE(rr.Contains(Point{49.999, -49.999}));
  
   // The pointy ends at the NE and SW corners
   CHECK_POINT_WITH_OFFSET(rr, Point(-49.70, -49.70), Point(-0.02, -0.02));
   CHECK_POINT_WITH_OFFSET(rr, Point(49.70, 49.70), Point(0.02, 0.02));
  
 // Checks two points symmetrical to the origin.
 #define CHECK_DIAGONAL_POINTS(p)                        \
   CHECK_POINT_WITH_OFFSET(rr, (p), Point(0.02, -0.02)); \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(-1, -1), Point(-0.02, 0.02));
  
   // A few other points along the edge
   CHECK_DIAGONAL_POINTS(Point(-40.0, -49.59));
   CHECK_DIAGONAL_POINTS(Point(-20.0, -45.64));
   CHECK_DIAGONAL_POINTS(Point(0.0, -37.01));
   CHECK_DIAGONAL_POINTS(Point(20.0, -21.96));
   CHECK_DIAGONAL_POINTS(Point(21.05, -20.92));
   CHECK_DIAGONAL_POINTS(Point(40.0, 5.68));
 #undef CHECK_POINT_AND_MIRRORS
 }

References CHECK_DIAGONAL_POINTS, CHECK_POINT_WITH_OFFSET, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundSuperellipse::MakeRectRadii().

◆ TEST() [451/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		TinyCornerContains
	)

Definition at line 616 of file round_superellipse_unittests.cc.

                                                 {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   // Rounded superellipses of bounds with even the tiniest corners does not
   // contain corners.
   auto tiny_corners = RoundSuperellipse::MakeRectRadii(
       bounds, RoundingRadii::MakeRadii({0.01f, 0.01f}));
  
   EXPECT_FALSE(tiny_corners.Contains({-50, -50}));
   EXPECT_FALSE(tiny_corners.Contains({-50, 50}));
   EXPECT_FALSE(tiny_corners.Contains({50, -50}));
   EXPECT_FALSE(tiny_corners.Contains({50, 50}));
 }

References impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadii(), and impeller::RoundSuperellipse::MakeRectRadii().

◆ TEST() [452/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		UniformEllipticalContains
	)

Definition at line 650 of file round_superellipse_unittests.cc.

                                                        {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   auto rr = RoundSuperellipse::MakeRectRadii(
       bounds, RoundingRadii::MakeRadii({5.0f, 10.0f}));
  
 #define CHECK_POINT_AND_MIRRORS(p)                                     \
   CHECK_POINT_WITH_OFFSET(rr, (p), Point(0.02, 0.02));                 \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(1, -1), Point(0.02, -0.02)); \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(-1, 1), Point(-0.02, 0.02)); \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(-1, -1), Point(-0.02, -0.02));
  
   CHECK_POINT_AND_MIRRORS(Point(0, 49.995));       // Top
   CHECK_POINT_AND_MIRRORS(Point(44.245, 49.911));  // Top curve start
   CHECK_POINT_AND_MIRRORS(Point(45.72, 49.75));    // Top joint
   CHECK_POINT_AND_MIRRORS(Point(48.51, 47.07));    // Circular arc mid
   CHECK_POINT_AND_MIRRORS(Point(49.87, 41.44));    // Right joint
   CHECK_POINT_AND_MIRRORS(Point(49.95, 38.49));    // Right curve start
   CHECK_POINT_AND_MIRRORS(Point(49.995, 0));       // Right
 #undef CHECK_POINT_AND_MIRRORS
 }

References CHECK_POINT_AND_MIRRORS, impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadii(), and impeller::RoundSuperellipse::MakeRectRadii().

◆ TEST() [453/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		UniformRectangularContains
	)

Definition at line 671 of file round_superellipse_unittests.cc.

                                                         {
   // The bounds is not centered at the origin and has unequal height and width.
   Rect bounds = Rect::MakeLTRB(0.0f, 0.0f, 50.0f, 100.0f);
   auto rr = RoundSuperellipse::MakeRectRadii(
       bounds, RoundingRadii::MakeRadii({23.0f, 30.0f}));
  
   Point center = bounds.GetCenter();
 #define CHECK_POINT_AND_MIRRORS(p)                                   \
   CHECK_POINT_WITH_OFFSET(rr, (p - center) * Point(1, 1) + center,   \
                           Point(0.02, 0.02));                        \
   CHECK_POINT_WITH_OFFSET(rr, (p - center) * Point(1, -1) + center,  \
                           Point(0.02, -0.02));                       \
   CHECK_POINT_WITH_OFFSET(rr, (p - center) * Point(-1, 1) + center,  \
                           Point(-0.02, 0.02));                       \
   CHECK_POINT_WITH_OFFSET(rr, (p - center) * Point(-1, -1) + center, \
                           Point(-0.02, -0.02));
  
   CHECK_POINT_AND_MIRRORS(Point(24.99, 99.99));  // Bottom mid edge
   CHECK_POINT_AND_MIRRORS(Point(29.99, 99.64));
   CHECK_POINT_AND_MIRRORS(Point(34.99, 98.06));
   CHECK_POINT_AND_MIRRORS(Point(39.99, 94.73));
   CHECK_POINT_AND_MIRRORS(Point(44.13, 89.99));
   CHECK_POINT_AND_MIRRORS(Point(48.46, 79.99));
   CHECK_POINT_AND_MIRRORS(Point(49.70, 69.99));
   CHECK_POINT_AND_MIRRORS(Point(49.97, 59.99));
   CHECK_POINT_AND_MIRRORS(Point(49.99, 49.99));  // Right mid edge
  
 #undef CHECK_POINT_AND_MIRRORS
 }

References CHECK_POINT_AND_MIRRORS, impeller::TRect< T >::GetCenter(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadii(), and impeller::RoundSuperellipse::MakeRectRadii().

◆ TEST() [454/523]

impeller::testing::TEST	(	RoundSuperellipseTest	,
		UniformSquareContains
	)

Definition at line 629 of file round_superellipse_unittests.cc.

                                                    {
   Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
   auto rr = RoundSuperellipse::MakeRectRadii(
       bounds, RoundingRadii::MakeRadii({5.0f, 5.0f}));
  
 #define CHECK_POINT_AND_MIRRORS(p)                                     \
   CHECK_POINT_WITH_OFFSET(rr, (p), Point(0.02, 0.02));                 \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(1, -1), Point(0.02, -0.02)); \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(-1, 1), Point(-0.02, 0.02)); \
   CHECK_POINT_WITH_OFFSET(rr, (p) * Point(-1, -1), Point(-0.02, -0.02));
  
   CHECK_POINT_AND_MIRRORS(Point(0, 49.995));      // Top
   CHECK_POINT_AND_MIRRORS(Point(44.245, 49.95));  // Top curve start
   CHECK_POINT_AND_MIRRORS(Point(45.72, 49.87));   // Top joint
   CHECK_POINT_AND_MIRRORS(Point(48.53, 48.53));   // Circular arc mid
   CHECK_POINT_AND_MIRRORS(Point(49.87, 45.72));   // Right joint
   CHECK_POINT_AND_MIRRORS(Point(49.95, 44.245));  // Right curve start
   CHECK_POINT_AND_MIRRORS(Point(49.995, 0));      // Right
 #undef CHECK_POINT_AND_MIRRORS
 }

References CHECK_POINT_AND_MIRRORS, impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadii(), and impeller::RoundSuperellipse::MakeRectRadii().

◆ TEST() [455/523]

impeller::testing::TEST	(	RSTransformTest	,
		CompareToMatrix
	)

Definition at line 32 of file rstransform_unittests.cc.

                                        {
   for (int tx = 0; tx <= 100; tx += 10) {
     for (int ty = 0; ty <= 100; ty += 10) {
       Point origin(tx, ty);
       for (int scale = 1; scale <= 20; scale += 5) {
         // Overshoot a full circle by 30 degrees
         for (int degrees = 0; degrees <= 390; degrees += 45) {
           auto matrix = Matrix::MakeTranslation(origin) *
                         Matrix::MakeRotationZ(Degrees(degrees)) *
                         Matrix::MakeScale(Vector2(scale, scale));
           auto rst = RSTransform::Make(origin, scale, Degrees(degrees));
           EXPECT_MATRIX_NEAR(rst.GetMatrix(), matrix);
           for (int w = 10; w <= 100; w += 10) {
             for (int h = 10; h <= 100; h += 10) {
               Quad q = rst.GetQuad(w, h);
               auto points = Rect::MakeWH(w, h).GetTransformedPoints(matrix);
               for (int i = 0; i < 4; i++) {
                 EXPECT_NEAR(q[i].x, points[i].x, kEhCloseEnough);
                 EXPECT_NEAR(q[i].y, points[i].y, kEhCloseEnough);
               }
             }
           }
         }
       }
     }
   }
 }

References EXPECT_MATRIX_NEAR, impeller::TRect< T >::GetTransformedPoints(), impeller::kEhCloseEnough, impeller::RSTransform::Make(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeWH(), points, and x.

◆ TEST() [456/523]

impeller::testing::TEST	(	RSTransformTest	,
		Construction
	)

Definition at line 14 of file rstransform_unittests.cc.

                                     {
   RSTransform transform = RSTransform::Make({10.0f, 12.0f}, 2.0f, Degrees(90));
  
   EXPECT_EQ(transform.scaled_cos, 0.0f);
   EXPECT_EQ(transform.scaled_sin, 2.0f);
   EXPECT_EQ(transform.translate_x, 10.0f);
   EXPECT_EQ(transform.translate_y, 12.0f);
  
   EXPECT_EQ(transform.GetBounds(20.0f, 30.0f),
             // relative corners are at
             // 0, 0
             // 0, 40
             // -60, 0
             // -60, 40
             // then add 10, 12 to all values
             Rect::MakeLTRB(10 + -2 * 30, 12 + 0, 10 + 0, 12 + 40));
 }

References impeller::RSTransform::Make(), impeller::TRect< Scalar >::MakeLTRB(), and transform.

◆ TEST() [457/523]

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() [458/523]

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() [459/523]

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() [460/523]

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() [461/523]

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() [462/523]

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() [463/523]

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() [464/523]

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() [465/523]

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() [466/523]

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() [467/523]

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() [468/523]

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() [469/523]

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() [470/523]

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

References impeller::saturated::b.

◆ TEST() [471/523]

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() [472/523]

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

References impeller::saturated::b.

◆ TEST() [473/523]

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() [474/523]

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

References impeller::saturated::b.

◆ TEST() [475/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		BackdropFilterEmptyCoverage
	)

Definition at line 163 of file save_layer_utils_unittests.cc.

                                                       {
   // Empty coverage with backdrop filter.
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/nullptr,                             //
       /*flood_output_coverage=*/true                        //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2400, 1800));
 }

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

◆ TEST() [476/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		BackdropFiterComputedCoverage
	)

Definition at line 29 of file save_layer_utils_unittests.cc.

                                                         {
   // Backdrop Filter, computed coverage
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),    //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/nullptr,
       /*flood_output_coverage=*/false,  //
       /*flood_input_coverage=*/true     //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2400, 1800));
 }

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

◆ TEST() [477/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		BasicEmptyCoverage
	)

Definition at line 137 of file save_layer_utils_unittests.cc.

                                              {
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/nullptr                              //
   );
  
   ASSERT_FALSE(coverage.has_value());
 }

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

◆ TEST() [478/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageLargerWithImageFilter
	)

Definition at line 246 of file save_layer_utils_unittests.cc.

                                                                                         {
   // Create an image filter that slightly stretches the coverage limit. Even
   // without the special logic for using the original content coverage, we
   // verify that we don't introduce any artifacts from the intersection.
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({0.9, 0.9, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 100, 100),  //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),    //
       /*image_filter=*/image_filter                         //
   );
  
   ASSERT_TRUE(coverage.has_value());
   // The transfomed coverage limit is ((0, 0), (111.111, 111.111)).
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [479/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageSmallerWithImageFilter
	)

Definition at line 227 of file save_layer_utils_unittests.cc.

                                                                                          {
   // Create an image filter that slightly shrinks the coverage limit
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({1.1, 1.1, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 100, 100),  //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),    //
       /*image_filter=*/image_filter                         //
   );
  
   ASSERT_TRUE(coverage.has_value());
   // The transfomed coverage limit is ((0, 0), (90.9091, 90.9091)).
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [480/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		CoverageLimitRespectedIfSubstantiallyDifferentFromContentCoverage
	)

Definition at line 267 of file save_layer_utils_unittests.cc.

                                                                         {
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({2, 2, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 1000, 1000),  //
       /*effect_transform=*/{},                                //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),      //
       /*image_filter=*/image_filter                           //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 50, 50));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [481/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DisjointCoverage
	)

Definition at line 94 of file save_layer_utils_unittests.cc.

                                            {
   // No intersection in coverage
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(200, 200, 210, 210),  //
       /*effect_transform=*/{},                                  //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),        //
       /*image_filter=*/nullptr                                  //
   );
  
   EXPECT_FALSE(coverage.has_value());
 }

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

◆ TEST() [482/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DisjointCoverageTransformedByImageFilter
	)

Definition at line 106 of file save_layer_utils_unittests.cc.

                                                                    {
   // Coverage disjoint from parent coverage but transformed into parent space
   // with image filter.
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeTranslation({-200, -200, 0}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(200, 200, 210, 210),  //
       /*effect_transform=*/{},                                  //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),        //
       /*image_filter=*/image_filter                             //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(200, 200, 210, 210));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeTranslation().

◆ TEST() [483/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DisjointCoveragTransformedByCTM
	)

Definition at line 123 of file save_layer_utils_unittests.cc.

                                                           {
   // Coverage disjoint from parent coverage.
   Matrix ctm = Matrix::MakeTranslation({-200, -200, 0});
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(200, 200, 210, 210),  //
       /*effect_transform=*/ctm,                                 //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),        //
       /*image_filter=*/nullptr                                  //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::Matrix::MakeTranslation().

◆ TEST() [484/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DontRoundUpCoverageWhenNotCloseToCoverageLimitHeight
	)

Definition at line 311 of file save_layer_utils_unittests.cc.

                                                                                {
   // X varies, translation is performed on coverage.
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 90, 50),  //
       /*effect_transform=*/{},                            //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
       /*image_filter=*/nullptr                            //
   );
  
   ASSERT_TRUE(coverage.has_value());
   // Size that matches coverage limit
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 90, 50));
 }

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

◆ TEST() [485/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DontRoundUpCoverageWhenNotCloseToCoverageLimitWidth
	)

Definition at line 297 of file save_layer_utils_unittests.cc.

                                                                               {
   // X varies, translation is performed on coverage.
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 50, 90),  //
       /*effect_transform=*/{},                            //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
       /*image_filter=*/nullptr                            //
   );
  
   ASSERT_TRUE(coverage.has_value());
   // Size that matches coverage limit
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 50, 90));
 }

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

◆ TEST() [486/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DontRoundUpCoverageWhenNotCloseToCoverageLimitWidthHeight
	)

Definition at line 325 of file save_layer_utils_unittests.cc.

                                                                 {
   // X varies, translation is performed on coverage.
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 50, 50),  //
       /*effect_transform=*/{},                            //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
       /*image_filter=*/nullptr                            //
   );
  
   ASSERT_TRUE(coverage.has_value());
   // Size that matches coverage limit
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 50, 50));
 }

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

◆ TEST() [487/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		FloodInputCoverage
	)

Definition at line 177 of file save_layer_utils_unittests.cc.

                                              {
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/nullptr,                             //
       /*flood_output_coverage=*/false,                      //
       /*flood_input_coverage=*/true                         //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2400, 1800));
 }

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

◆ TEST() [488/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		FloodInputCoverageWithImageFilter
	)

Definition at line 191 of file save_layer_utils_unittests.cc.

                                                             {
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({0.5, 0.5, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/image_filter,                        //
       /*flood_output_coverage=*/false,                      //
       /*flood_input_coverage=*/true                         //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 4800, 3600));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [489/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		FloodInputCoverageWithImageFilterWithNoCoverageProducesNoCoverage
	)

Definition at line 208 of file save_layer_utils_unittests.cc.

                                                                         {
   // Even if we flood the input coverage due to a bdf, we can still cull out the
   // layer if the image filter results in no coverage.
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({1, 1, 0}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/image_filter,                        //
       /*flood_output_coverage=*/false,                      //
       /*flood_input_coverage=*/true                         //
   );
  
   ASSERT_FALSE(coverage.has_value());
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [490/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFilterEmptyCoverage
	)

Definition at line 148 of file save_layer_utils_unittests.cc.

                                                    {
   // Empty coverage with Image Filter
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeTranslation({-200, -200, 0}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/image_filter                         //
   );
  
   ASSERT_FALSE(coverage.has_value());
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeTranslation().

◆ TEST() [491/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFiterComputedCoverage
	)

Definition at line 44 of file save_layer_utils_unittests.cc.

                                                      {
   // Image Filter, computed coverage
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({2, 2, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),    //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/image_filter                         //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [492/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFiterLargeScaleComputedCoverageLargerThanBoundsLimit
	)

Definition at line 77 of file save_layer_utils_unittests.cc.

                                                                 {
   // Image Filter scaling small, computed coverage is larger than bounds limit.
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({0.5, 0.5, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),  //
       /*effect_transform=*/{},                            //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 5, 5),      //
       /*image_filter=*/image_filter                       //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [493/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFiterSmallScaleComputedCoverageLargerThanBoundsLimit
	)

Definition at line 60 of file save_layer_utils_unittests.cc.

                                                                 {
   // Image Filter scaling large, computed coverage is larger than bounds limit.
   auto image_filter = FilterContents::MakeMatrixFilter(
       FilterInput::Make(Rect()), Matrix::MakeScale({2, 2, 1}), {});
  
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),  //
       /*effect_transform=*/{},                            //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 5, 5),      //
       /*image_filter=*/image_filter                       //
   );
  
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2.5, 2.5));
 }

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [494/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		RoundUpCoverageWhenCloseToCoverageLimit
	)

Definition at line 283 of file save_layer_utils_unittests.cc.

                                                                   {
   // X varies, translation is performed on coverage.
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 90, 90),  //
       /*effect_transform=*/{},                            //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
       /*image_filter=*/nullptr                            //
   );
  
   ASSERT_TRUE(coverage.has_value());
   // Size that matches coverage limit
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
 }

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

◆ TEST() [495/523]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		SimplePaintComputedCoverage
	)

Definition at line 17 of file save_layer_utils_unittests.cc.

                                                       {
   // Basic Case, simple paint, computed coverage
   auto coverage = ComputeSaveLayerCoverage(
       /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),    //
       /*effect_transform=*/{},                              //
       /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
       /*image_filter=*/nullptr                              //
   );
   ASSERT_TRUE(coverage.has_value());
   EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
 }

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

◆ TEST() [496/523]

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

References impeller::ShaderArchiveWriter::AddShader(), impeller::ShaderArchiveWriter::CreateMapping(), CreateMappingFromString(), CreateStringFromMapping(), impeller::ShaderArchive::GetMapping(), impeller::ShaderArchive::GetShaderCount(), impeller::ShaderArchive::IsValid(), impeller::kFragment, and impeller::kVertex.

◆ TEST() [497/523]

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() [498/523]

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() [499/523]

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() [500/523]

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() [501/523]

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() [502/523]

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

Definition at line 46 of file skia_conversions_unittests.cc.

                                    {
   // Create a color with alpha, red, green, and blue values that are all
   // trivially divisible by 255 so that we can test the conversion results in
   // correct scalar values.
   //                                                AARRGGBB
   const flutter::DlColor color = flutter::DlColor(0x8040C020);
   auto converted_color = skia_conversions::ToColor(color);
  
   ASSERT_TRUE(ScalarNearlyEqual(converted_color.alpha, 0x80 * (1.0f / 255)));
   ASSERT_TRUE(ScalarNearlyEqual(converted_color.red, 0x40 * (1.0f / 255)));
   ASSERT_TRUE(ScalarNearlyEqual(converted_color.green, 0xC0 * (1.0f / 255)));
   ASSERT_TRUE(ScalarNearlyEqual(converted_color.blue, 0x20 * (1.0f / 255)));
 }

References impeller::ScalarNearlyEqual(), and impeller::skia_conversions::ToColor().

◆ TEST() [503/523]

impeller::testing::TEST	(	SkiaConversionTest	,
		ToSamplerDescriptor
	)

Definition at line 17 of file skia_conversions_unittests.cc.

                                               {
   EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                 flutter::DlImageSampling::kNearestNeighbor)
                 .min_filter,
             impeller::MinMagFilter::kNearest);
   EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                 flutter::DlImageSampling::kNearestNeighbor)
                 .mip_filter,
             impeller::MipFilter::kBase);
  
   EXPECT_EQ(
       skia_conversions::ToSamplerDescriptor(flutter::DlImageSampling::kLinear)
           .min_filter,
       impeller::MinMagFilter::kLinear);
   EXPECT_EQ(
       skia_conversions::ToSamplerDescriptor(flutter::DlImageSampling::kLinear)
           .mip_filter,
       impeller::MipFilter::kBase);
  
   EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                 flutter::DlImageSampling::kMipmapLinear)
                 .min_filter,
             impeller::MinMagFilter::kLinear);
   EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                 flutter::DlImageSampling::kMipmapLinear)
                 .mip_filter,
             impeller::MipFilter::kLinear);
 }

References impeller::kBase, impeller::kLinear, impeller::kNearest, and impeller::skia_conversions::ToSamplerDescriptor().

◆ TEST() [504/523]

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

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

References impeller::SPrintF().

◆ TEST() [505/523]

impeller::testing::TEST	(	SurfaceContextVK	,
		TearsDownSwapchain
	)

Definition at line 31 of file surface_context_vk_unittests.cc.

                                            {
   SetSwapchainImageSize({100, 100});
   std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
  
   vk::UniqueSurfaceKHR surface = CreateSurface(*context);
   SurfaceContextVK surface_context(context);
  
   EXPECT_TRUE(surface_context.SetWindowSurface(std::move(surface), {100, 100}));
   EXPECT_NE(surface_context.AcquireNextSurface(), nullptr);
  
   surface_context.TeardownSwapchain();
  
   EXPECT_EQ(surface_context.AcquireNextSurface(), nullptr);
 }

References impeller::SurfaceContextVK::AcquireNextSurface(), impeller::SurfaceContextVK::SetWindowSurface(), and impeller::SurfaceContextVK::TeardownSwapchain().

◆ TEST() [506/523]

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

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

References impeller::TPoint< T >::GetLength(), impeller::Tessellator::kCircleTolerance, impeller::kPiOver2, impeller::Matrix::MakeScale(), and transform.

◆ TEST() [507/523]

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

Definition at line 513 of file tessellator_unittests.cc.

                                                    {
   // This path is not technically empty (it has a size in one dimension), but
   // it contains only move commands and no actual path segment definitions.
   flutter::DlPathBuilder builder;
   builder.MoveTo({0, 0});
   builder.MoveTo({10, 10});
  
   std::vector<Point> points;
   std::vector<uint16_t> indices;
   Tessellator::TessellateConvexInternal(builder.TakePath(), points, indices,
                                         3.0f);
  
   EXPECT_TRUE(points.empty());
   EXPECT_TRUE(indices.empty());
 }

References points, and impeller::Tessellator::TessellateConvexInternal().

◆ TEST() [508/523]

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

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

References EXPECT_POINT_NEAR, impeller::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), and transform.

◆ TEST() [509/523]

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

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

References EXPECT_POINT_NEAR, impeller::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST() [510/523]

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

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

References EXPECT_POINT_NEAR, impeller::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST() [511/523]

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

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

References EXPECT_POINT_NEAR, impeller::TPoint< T >::GetLength(), impeller::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), transform, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [512/523]

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

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

References EXPECT_POINT_NEAR, impeller::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), and transform.

◆ TEST() [513/523]

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

Definition at line 96 of file tessellator_unittests.cc.

                                         {
   {
     std::vector<Point> points;
     std::vector<uint16_t> indices;
     // Sanity check simple rectangle.
     Tessellator::TessellateConvexInternal(
         flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 10, 10)), points,
         indices, 1.0);
  
     // Note: the origin point is repeated but not referenced in the indices
     // below
     std::vector<Point> expected = {{0, 0}, {10, 0}, {10, 10}, {0, 10}, {0, 0}};
     std::vector<uint16_t> expected_indices = {0, 1, 3, 2};
     EXPECT_EQ(points, expected);
     EXPECT_EQ(indices, expected_indices);
   }
  
   {
     std::vector<Point> points;
     std::vector<uint16_t> indices;
     Tessellator::TessellateConvexInternal(
         flutter::DlPath(flutter::DlPathBuilder{}
                             .AddRect(Rect::MakeLTRB(0, 0, 10, 10))
                             .AddRect(Rect::MakeLTRB(20, 20, 30, 30))
                             .TakePath()),
         points, indices, 1.0);
  
     std::vector<Point> expected = {{0, 0},   {10, 0},  {10, 10}, {0, 10},
                                    {0, 0},   {20, 20}, {30, 20}, {30, 30},
                                    {20, 30}, {20, 20}};
     std::vector<uint16_t> expected_indices = {0, 1, 3, 2, 2, 5, 5, 6, 8, 7};
     EXPECT_EQ(points, expected);
     EXPECT_EQ(indices, expected_indices);
   }
 }

References impeller::TRect< Scalar >::MakeLTRB(), points, and impeller::Tessellator::TessellateConvexInternal().

◆ TEST() [514/523]

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

Definition at line 133 of file tessellator_unittests.cc.

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

References impeller::LineTo(), points, and impeller::Tessellator::TessellateConvexInternal().

◆ TEST() [515/523]

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

Definition at line 16 of file tessellator_unittests.cc.

                                                                     {
   // Zero points.
   {
     TessellatorLibtess t;
     auto path = flutter::DlPathBuilder{}  //
                     .SetFillType(FillType::kOdd)
                     .TakePath();
     TessellatorLibtess::Result result = t.Tessellate(
         path, 1.0f,
         [](const float* vertices, size_t vertices_count,
            const uint16_t* indices, size_t indices_count) { return true; });
  
     ASSERT_EQ(result, TessellatorLibtess::Result::kInputError);
   }
  
   // One point.
   {
     TessellatorLibtess t;
     auto path = flutter::DlPathBuilder{}
                     .LineTo({0, 0})
                     .SetFillType(FillType::kOdd)
                     .TakePath();
     TessellatorLibtess::Result result = t.Tessellate(
         path, 1.0f,
         [](const float* vertices, size_t vertices_count,
            const uint16_t* indices, size_t indices_count) { return true; });
  
     ASSERT_EQ(result, TessellatorLibtess::Result::kSuccess);
   }
  
   // Two points.
   {
     TessellatorLibtess t;
     auto path = flutter::DlPathBuilder{}
                     .MoveTo({0, 0})
                     .LineTo({0, 1})
                     .SetFillType(FillType::kOdd)
                     .TakePath();
     TessellatorLibtess::Result result = t.Tessellate(
         path, 1.0f,
         [](const float* vertices, size_t vertices_count,
            const uint16_t* indices, size_t indices_count) { return true; });
  
     ASSERT_EQ(result, TessellatorLibtess::Result::kSuccess);
   }
  
   // Many points.
   {
     TessellatorLibtess t;
     flutter::DlPathBuilder builder;
     for (int i = 0; i < 1000; i++) {
       auto coord = i * 1.0f;
       builder.MoveTo({coord, coord}).LineTo({coord + 1, coord + 1});
     }
     auto path = builder.SetFillType(FillType::kOdd).TakePath();
     TessellatorLibtess::Result result = t.Tessellate(
         path, 1.0f,
         [](const float* vertices, size_t vertices_count,
            const uint16_t* indices, size_t indices_count) { return true; });
  
     ASSERT_EQ(result, TessellatorLibtess::Result::kSuccess);
   }
  
   // Closure fails.
   {
     TessellatorLibtess t;
     auto path = flutter::DlPathBuilder{}
                     .MoveTo({0, 0})
                     .LineTo({0, 1})
                     .SetFillType(FillType::kOdd)
                     .TakePath();
     TessellatorLibtess::Result result = t.Tessellate(
         path, 1.0f,
         [](const float* vertices, size_t vertices_count,
            const uint16_t* indices, size_t indices_count) { return false; });
  
     ASSERT_EQ(result, TessellatorLibtess::Result::kInputError);
   }
 }

References impeller::TessellatorLibtess::kInputError, impeller::kOdd, impeller::TessellatorLibtess::kSuccess, impeller::LineTo(), and impeller::TessellatorLibtess::Tessellate().

◆ TEST() [516/523]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateMutex
	)

Definition at line 36 of file base_unittests.cc.

                                  {
   Foo f = {};
  
   // f.a = 100; <--- Static analysis error.
   f.mtx.Lock();
   f.a = 100;
   f.mtx.Unlock();
 }

References impeller::testing::Foo::mtx.

◆ TEST() [517/523]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateMutexLock
	)

Definition at line 45 of file base_unittests.cc.

                                      {
   Foo f = {};
  
   // f.a = 100; <--- Static analysis error.
   auto a = Lock(f.mtx);
   f.a = 100;
 }

References impeller::testing::Foo::mtx.

◆ TEST() [518/523]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateRWMutex
	)

Definition at line 53 of file base_unittests.cc.

                                    {
   RWFoo f = {};
  
   // f.a = 100; <--- Static analysis error.
   f.mtx.LockWriter();
   f.a = 100;
   f.mtx.UnlockWriter();
   // int b = f.a; <--- Static analysis error.
   f.mtx.LockReader();
   [[maybe_unused]] int b = f.a;  // NOLINT(clang-analyzer-deadcode.DeadStores)
   f.mtx.UnlockReader();
 }

References impeller::saturated::b, and impeller::testing::RWFoo::mtx.

◆ TEST() [519/523]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateRWMutexLock
	)

Definition at line 66 of file base_unittests.cc.

                                        {
   RWFoo f = {};
  
   // f.a = 100; <--- Static analysis error.
   {
     auto write_lock = WriterLock{f.mtx};
     f.a = 100;
   }
  
   // int b = f.a; <--- Static analysis error.
   {
     auto read_lock = ReaderLock(f.mtx);
     [[maybe_unused]] int b = f.a;  // NOLINT(clang-analyzer-deadcode.DeadStores)
   }
  
   // f.mtx.UnlockReader(); <--- Static analysis error.
 }

References impeller::saturated::b, and impeller::testing::RWFoo::mtx.

◆ TEST() [520/523]

impeller::testing::TEST	(	TrigTest	,
		MultiplyByScalarRadius
	)

Definition at line 65 of file trig_unittests.cc.

                                        {
   for (int i = 0; i <= 360; i++) {
     for (int i = 1; i <= 10; i++) {
       Scalar radius = i * 5.0f;
       EXPECT_EQ(Trig(Degrees(i)) * radius,
                 Point(radius * std::cos(i * kPi / 180),
                       radius * std::sin(i * kPi / 180)))
           << "at " << i << " degrees and radius " << radius;
     }
   }
 }

References impeller::kPi.

◆ TEST() [521/523]

impeller::testing::TEST	(	TrigTest	,
		TrigAngles
	)

Definition at line 15 of file trig_unittests.cc.

                            {
   {
     Trig trig(Degrees(0.0));
     EXPECT_EQ(trig.cos, 1.0);
     EXPECT_EQ(trig.sin, 0.0);
   }
  
   {
     Trig trig(Radians(0.0));
     EXPECT_EQ(trig.cos, 1.0);
     EXPECT_EQ(trig.sin, 0.0);
   }
  
   {
     Trig trig(Degrees(30.0));
     EXPECT_NEAR(trig.cos, sqrt(0.75), kEhCloseEnough);
     EXPECT_NEAR(trig.sin, 0.5, kEhCloseEnough);
   }
  
   {
     Trig trig(Radians(kPi / 6.0));
     EXPECT_NEAR(trig.cos, sqrt(0.75), kEhCloseEnough);
     EXPECT_NEAR(trig.sin, 0.5, kEhCloseEnough);
   }
  
   {
     Trig trig(Degrees(60.0));
     EXPECT_NEAR(trig.cos, 0.5, kEhCloseEnough);
     EXPECT_NEAR(trig.sin, sqrt(0.75), kEhCloseEnough);
   }
  
   {
     Trig trig(Radians(kPi / 3.0));
     EXPECT_NEAR(trig.cos, 0.5, kEhCloseEnough);
     EXPECT_NEAR(trig.sin, sqrt(0.75), kEhCloseEnough);
   }
  
   {
     Trig trig(Degrees(90.0));
     EXPECT_NEAR(trig.cos, 0.0, kEhCloseEnough);
     EXPECT_NEAR(trig.sin, 1.0, kEhCloseEnough);
   }
  
   {
     Trig trig(Radians(kPi / 2.0));
     EXPECT_NEAR(trig.cos, 0.0, kEhCloseEnough);
     EXPECT_NEAR(trig.sin, 1.0, kEhCloseEnough);
   }
 }

References impeller::Trig::cos, impeller::kEhCloseEnough, impeller::kPi, and impeller::Trig::sin.

◆ TEST() [522/523]

impeller::testing::TEST	(	TypographerTest	,
		RectanglePackerFillsRows
	)

Definition at line 413 of file typographer_unittests.cc.

                                                 {
   auto skyline = RectanglePacker::Factory(257, 256);
  
   // Fill up the first row.
   IPoint16 loc;
   for (auto i = 0u; i < 16; i++) {
     skyline->AddRect(16, 16, &loc);
   }
   // Last rectangle still in first row.
   EXPECT_EQ(loc.x(), 256 - 16);
   EXPECT_EQ(loc.y(), 0);
  
   // Fill up second row.
   for (auto i = 0u; i < 16; i++) {
     skyline->AddRect(16, 16, &loc);
   }
  
   EXPECT_EQ(loc.x(), 256 - 16);
   EXPECT_EQ(loc.y(), 16);
 }

References impeller::RectanglePacker::Factory(), impeller::IPoint16::x(), and impeller::IPoint16::y().

◆ TEST() [523/523]

impeller::testing::TEST	(	UniqueHandleGLES	,
		MakeUntracked
	)

Definition at line 26 of file unique_handle_gles_unittests.cc.

                                       {
   auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  
   EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)).Times(1);
  
   std::shared_ptr<MockGLES> mock_gled =
       MockGLES::Init(std::move(mock_gles_impl));
   ProcTableGLES::Resolver resolver = kMockResolverGLES;
   auto proc_table = std::make_unique<ProcTableGLES>(resolver);
   auto worker = std::make_shared<TestWorker>();
   auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
   reactor->AddWorker(worker);
  
   UniqueHandleGLES handle =
       UniqueHandleGLES::MakeUntracked(reactor, HandleType::kTexture);
   EXPECT_FALSE(handle.Get().IsDead());
 }

References impeller::UniqueHandleGLES::Get(), impeller::HandleGLES::IsDead(), impeller::kTexture, and impeller::UniqueHandleGLES::MakeUntracked().

◆ TEST_F()

impeller::testing::TEST_F	(	GoldenTests	,
		ConicalGradient
	)

Definition at line 80 of file golden_tests.cc.

                                      {
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
   paint.setDrawStyle(flutter::DlDrawStyle::kFill);
  
   flutter::DlColor colors[2] = {flutter::DlColor::RGBA(1, 0, 0, 1),
                                 flutter::DlColor::RGBA(0, 0, 1, 1)};
   Scalar stops[2] = {0, 1};
  
   paint.setColorSource(flutter::DlColorSource::MakeConical(
       /*start_center=*/{125, 125},               //
       /*start_radius=*/125, {180, 180},          //
       /*end_radius=*/0,                          //
       /*stop_count=*/2,                          //
       /*colors=*/colors,                         //
       /*stops=*/stops,                           //
       /*tile_mode=*/flutter::DlTileMode::kClamp  //
       ));
  
   builder.DrawRect(DlRect::MakeXYWH(10, 10, 250, 250), paint);
  
   auto aiks_context =
       AiksContext(Screenshotter().GetPlayground().GetContext(), nullptr);
   auto screenshot = Screenshotter().MakeScreenshot(
       aiks_context,
       DisplayListToTexture(builder.Build(), {240, 240}, aiks_context));
   ASSERT_TRUE(SaveScreenshot(std::move(screenshot)));
 }

References impeller::DisplayListToTexture(), and impeller::testing::Screenshotter::MakeScreenshot().

◆ TEST_P() [1/545]

impeller::testing::TEST_P	(	AiksTest	,
		AdvancedBlendColorFilterWithDestinationOpacity
	)

Definition at line 907 of file aiks_dl_blend_unittests.cc.

                                                                  {
   DisplayListBuilder builder;
  
   builder.DrawPaint(DlPaint(DlColor::kWhite()));
  
   DlPaint save_paint;
   save_paint.setOpacity(0.3);
   save_paint.setColorFilter(DlColorFilter::MakeBlend(DlColor::kTransparent(),
                                                      DlBlendMode::kSaturation));
   builder.SaveLayer(std::nullopt, &save_paint);
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300),
                    DlPaint(DlColor::kMaroon()));
   builder.DrawRect(DlRect::MakeXYWH(200, 200, 300, 300),
                    DlPaint(DlColor::kBlue()));
   builder.Restore();
  
   // Should be solid red as the destructive color filter floods the clip.
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [2/545]

impeller::testing::TEST_P	(	AiksTest	,
		ArcWithZeroSweepAndBlur
	)

Definition at line 839 of file aiks_dl_path_unittests.cc.

                                           {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
  
   std::vector<DlColor> colors = {DlColor::RGBA(1.0, 0.0, 0.0, 1.0),
                                  DlColor::RGBA(0.0, 0.0, 0.0, 1.0)};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   paint.setColorSource(
       DlColorSource::MakeSweep({100, 100}, 45, 135, stops.size(), colors.data(),
                                stops.data(), DlTileMode::kMirror));
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
  
   DlPathBuilder path_builder;
   path_builder.AddArc(DlRect::MakeXYWH(10, 10, 100, 100),  //
                       DlDegrees(0), DlDegrees(0));
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Check that this empty picture can be created without crashing.
   builder.Build();
 }

References x.

◆ TEST_P() [3/545]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownBackdropId
	)

Definition at line 175 of file canvas_unittests.cc.

                                               {
   ContentContext context(GetContext(), nullptr);
   if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
     GTEST_SKIP() << "Test requires device with framebuffer fetch";
   }
   auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                  /*requires_readback=*/true);
   // 3 backdrop filters all with same id.
   std::unordered_map<int64_t, BackdropData> data;
   data[1] = BackdropData{.backdrop_count = 3};
   canvas->SetBackdropData(data, 3);
  
   auto blur =
       flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
  
   EXPECT_TRUE(canvas->RequiresReadback());
   canvas->DrawRect(flutter::DlRect::MakeLTRB(0, 0, 50, 50),
                    {.color = Color::Azure()});
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1, /*can_distribute_opacity=*/false,
                     /*backdrop_id=*/1);
   canvas->Restore();
   EXPECT_FALSE(canvas->RequiresReadback());
  
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1, /*can_distribute_opacity=*/false,
                     /*backdrop_id=*/1);
   canvas->Restore();
   EXPECT_FALSE(canvas->RequiresReadback());
  
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1, /*can_distribute_opacity=*/false,
                     /*backdrop_id=*/1);
   canvas->Restore();
   EXPECT_FALSE(canvas->RequiresReadback());
 }

References impeller::Color::Azure(), impeller::BackdropData::backdrop_count, CreateTestCanvas(), data, impeller::ContentContext::GetDeviceCapabilities(), impeller::kContainsContents, impeller::TRect< Scalar >::MakeLTRB(), and impeller::Capabilities::SupportsFramebufferFetch().

◆ TEST_P() [4/545]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownBackdropIdMixed
	)

Definition at line 215 of file canvas_unittests.cc.

                                                    {
   ContentContext context(GetContext(), nullptr);
   if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
     GTEST_SKIP() << "Test requires device with framebuffer fetch";
   }
   auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                  /*requires_readback=*/true);
   // 3 backdrop filters, 2 with same id.
   std::unordered_map<int64_t, BackdropData> data;
   data[1] = BackdropData{.backdrop_count = 2};
   canvas->SetBackdropData(data, 3);
  
   auto blur =
       flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
  
   EXPECT_TRUE(canvas->RequiresReadback());
   canvas->DrawRect(flutter::DlRect::MakeLTRB(0, 0, 50, 50),
                    {.color = Color::Azure()});
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents, 1, false);
   canvas->Restore();
   EXPECT_TRUE(canvas->RequiresReadback());
  
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents, 1, false, 1);
   canvas->Restore();
   EXPECT_FALSE(canvas->RequiresReadback());
  
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents, 1, false, 1);
   canvas->Restore();
   EXPECT_FALSE(canvas->RequiresReadback());
 }

References impeller::Color::Azure(), impeller::BackdropData::backdrop_count, CreateTestCanvas(), data, impeller::ContentContext::GetDeviceCapabilities(), impeller::kContainsContents, impeller::TRect< Scalar >::MakeLTRB(), and impeller::Capabilities::SupportsFramebufferFetch().

◆ TEST_P() [5/545]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownNormal
	)

Definition at line 140 of file canvas_unittests.cc.

                                           {
   ContentContext context(GetContext(), nullptr);
   if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
     GTEST_SKIP() << "Test requires device with framebuffer fetch";
   }
   auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                  /*requires_readback=*/true);
   // 3 backdrop filters
   canvas->SetBackdropData({}, 3);
  
   auto blur =
       flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
   flutter::DlRect rect = flutter::DlRect::MakeLTRB(0, 0, 50, 50);
  
   EXPECT_TRUE(canvas->RequiresReadback());
   canvas->DrawRect(rect, {.color = Color::Azure()});
   canvas->SaveLayer({}, rect, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1);
   canvas->Restore();
   EXPECT_TRUE(canvas->RequiresReadback());
  
   canvas->SaveLayer({}, rect, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1);
   canvas->Restore();
   EXPECT_TRUE(canvas->RequiresReadback());
  
   canvas->SaveLayer({}, rect, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1);
   canvas->Restore();
   EXPECT_FALSE(canvas->RequiresReadback());
 }

References impeller::Color::Azure(), CreateTestCanvas(), impeller::ContentContext::GetDeviceCapabilities(), impeller::kContainsContents, impeller::TRect< Scalar >::MakeLTRB(), and impeller::Capabilities::SupportsFramebufferFetch().

◆ TEST_P() [6/545]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownWithNestedSaveLayers
	)

Definition at line 252 of file canvas_unittests.cc.

                                                         {
   ContentContext context(GetContext(), nullptr);
   if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
     GTEST_SKIP() << "Test requires device with framebuffer fetch";
   }
   auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                  /*requires_readback=*/true);
  
   canvas->SetBackdropData({}, 2);
  
   auto blur =
       flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
  
   EXPECT_TRUE(canvas->RequiresReadback());
   canvas->DrawRect(flutter::DlRect::MakeLTRB(0, 0, 50, 50),
                    {.color = Color::Azure()});
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/3);
  
   // This filter is nested in the first saveLayer. We cannot restore to onscreen
   // here.
   canvas->SaveLayer({}, std::nullopt, blur.get(),
                     ContentBoundsPromise::kContainsContents,
                     /*total_content_depth=*/1);
   canvas->Restore();
   EXPECT_TRUE(canvas->RequiresReadback());
  
   canvas->Restore();
   EXPECT_TRUE(canvas->RequiresReadback());
 }

References impeller::Color::Azure(), CreateTestCanvas(), impeller::ContentContext::GetDeviceCapabilities(), impeller::kContainsContents, impeller::TRect< Scalar >::MakeLTRB(), and impeller::Capabilities::SupportsFramebufferFetch().

◆ TEST_P() [7/545]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropFilterOverUnclosedClip
	)

Definition at line 2080 of file aiks_dl_basic_unittests.cc.

                                                  {
   DisplayListBuilder builder;
  
   builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
   builder.Save();
   {
     builder.ClipRect(DlRect::MakeLTRB(100, 100, 800, 800));
  
     builder.Save();
     {
       builder.ClipRect(DlRect::MakeLTRB(600, 600, 800, 800));
       builder.DrawPaint(DlPaint().setColor(DlColor::kRed()));
       builder.DrawPaint(DlPaint().setColor(DlColor::kBlue().withAlphaF(0.5)));
       builder.ClipRect(DlRect::MakeLTRB(700, 700, 750, 800));
       builder.DrawPaint(DlPaint().setColor(DlColor::kRed().withAlphaF(0.5)));
     }
     builder.Restore();
  
     auto image_filter = DlImageFilter::MakeBlur(10, 10, DlTileMode::kDecal);
     builder.SaveLayer(std::nullopt, nullptr, image_filter.get());
   }
   builder.Restore();
   builder.DrawCircle(DlPoint(100, 100), 100,
                      DlPaint().setColor(DlColor::kAqua()));
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [8/545]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropRestoreUsesCorrectCoverageForFirstRestoredClip
	)

Definition at line 902 of file aiks_dl_unittests.cc.

                                                                          {
   DisplayListBuilder builder;
  
   DlPaint paint;
   // Add a difference clip that cuts out the bottom right corner
   builder.ClipRect(DlRect::MakeLTRB(50, 50, 100, 100), DlClipOp::kDifference);
  
   // Draw a red rectangle that's going to be completely covered by green later.
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
  
   // Add a clip restricting the backdrop filter to the top right corner.
   auto count = builder.GetSaveCount();
   builder.Save();
   {
     builder.ClipRect(DlRect::MakeLTRB(0, 0, 100, 100));
     {
       // Create a save layer with a backdrop blur filter.
       auto backdrop_filter =
           DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal);
       builder.SaveLayer(std::nullopt, nullptr, backdrop_filter.get());
     }
   }
   builder.RestoreToCount(count);
  
   // Finally, overwrite all the previous stuff with green.
   paint.setColor(DlColor::kGreen());
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [9/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModePlusAlphaColorFilterWideGamut
	)

Definition at line 432 of file aiks_dl_blend_unittests.cc.

                                                          {
   EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
             PixelFormat::kB10G10R10A10XR);
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
  
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.2, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   DlPaint save_paint;
   save_paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::RGBA(1, 0, 0, 1), DlBlendMode::kPlus));
   builder.SaveLayer(std::nullopt, &save_paint);
  
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
  
   paint.setColor(DlColor::kWhite());
  
   auto rect = Rect::MakeXYWH(100, 100, 400, 400).Expand(-100, -100);
   builder.DrawImageRect(
       DlImageImpeller::Make(texture),
       DlRect::MakeWH(texture->GetSize().width, texture->GetSize().height),
       DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),  //
                        rect.GetRight(), rect.GetBottom()),
       DlImageSampling::kMipmapLinear, &paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::TRect< T >::Expand(), impeller::kB10G10R10A10XR, impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeXYWH(), and x.

◆ TEST_P() [10/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModePlusAlphaWideGamut
	)

Definition at line 400 of file aiks_dl_blend_unittests.cc.

                                               {
   EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
             PixelFormat::kB10G10R10A10XR);
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
  
   DisplayListBuilder builder;
   DlPaint paint;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   paint.setColor(DlColor::RGBA(0.9, 1, 0.9, 1.0));
   builder.DrawPaint(paint);
   builder.SaveLayer(std::nullopt);
  
   paint.setBlendMode(DlBlendMode::kPlus);
   paint.setColor(DlColor::kRed());
  
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
   paint.setColor(DlColor::kWhite());
  
   auto rect = Rect::MakeXYWH(100, 100, 400, 400).Expand(-100, -100);
   builder.DrawImageRect(
       DlImageImpeller::Make(texture),
       DlRect::MakeWH(texture->GetSize().width, texture->GetSize().height),
       DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),  //
                        rect.GetRight(), rect.GetBottom()),
       DlImageSampling::kMipmapLinear, &paint);
   builder.Restore();
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::TRect< T >::Expand(), impeller::kB10G10R10A10XR, impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeXYWH(), and x.

◆ TEST_P() [11/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModeShouldCoverWholeScreen
	)

Definition at line 82 of file aiks_dl_blend_unittests.cc.

                                                   {
   DisplayListBuilder builder;
   DlPaint paint;
  
   paint.setColor(DlColor::kRed());
   builder.DrawPaint(paint);
  
   paint.setBlendMode(DlBlendMode::kSrcOver);
   builder.SaveLayer(std::nullopt, &paint);
  
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
  
   paint.setBlendMode(DlBlendMode::kSrc);
   builder.SaveLayer(std::nullopt, &paint);
  
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(200, 200, 200, 200), paint);
  
   builder.Restore();
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [12/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlurGradientWithOpacity
	)

Definition at line 1344 of file aiks_dl_blur_unittests.cc.

                                           {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   std::vector<DlColor> colors = {DlColor(0xFFFF0000), DlColor(0xFF00FF00)};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   auto gradient = DlColorSource::MakeLinear(
       {0, 0}, {400, 400}, 2, colors.data(), stops.data(), DlTileMode::kClamp);
  
   DlPaint save_paint;
   save_paint.setOpacity(0.5);
   builder.SaveLayer(std::nullopt, &save_paint);
  
   DlPaint paint;
   paint.setColorSource(gradient);
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1));
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), paint);
  
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [13/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlurHasNoEdge
	)

Definition at line 438 of file aiks_dl_blur_unittests.cc.

                                 {
   Scalar sigma = 47.6;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Sigma", &sigma, 0, 50);
       ImGui::End();
     }
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.DrawPaint({});
  
     DlPaint paint;
     paint.setColor(DlColor::kGreen());
     paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
  
     builder.DrawRect(DlRect::MakeXYWH(300, 300, 200, 200), paint);
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), and x.

◆ TEST_P() [14/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlurredCircleWithStrokeWidth
	)

Definition at line 1083 of file aiks_dl_path_unittests.cc.

                                                {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kGreen());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(30);
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 5));
  
   builder.DrawCircle(DlPoint(200, 200), 100, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [15/545]

impeller::testing::TEST_P	(	AiksTest	,
		BlurredRectangleWithShader
	)

Definition at line 1197 of file aiks_dl_blur_unittests.cc.

                                              {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   auto paint_lines = [&builder](Scalar dx, Scalar dy, DlPaint paint) {
     auto draw_line = [&builder, &paint](DlPoint a, DlPoint b) {
       DlPath line = DlPath::MakeLine(a, b);
       builder.DrawPath(line, paint);
     };
     paint.setStrokeWidth(5);
     paint.setDrawStyle(DlDrawStyle::kStroke);
     draw_line(DlPoint(dx + 100, dy + 100), DlPoint(dx + 200, dy + 200));
     draw_line(DlPoint(dx + 100, dy + 200), DlPoint(dx + 200, dy + 100));
     draw_line(DlPoint(dx + 150, dy + 100), DlPoint(dx + 200, dy + 150));
     draw_line(DlPoint(dx + 100, dy + 150), DlPoint(dx + 150, dy + 200));
   };
  
   AiksContext renderer(GetContext(), nullptr);
   DisplayListBuilder recorder_builder;
   for (int x = 0; x < 5; ++x) {
     for (int y = 0; y < 5; ++y) {
       DlRect rect = DlRect::MakeXYWH(x * 20, y * 20, 20, 20);
       DlPaint paint;
       paint.setColor(((x + y) & 1) == 0 ? DlColor::kYellow()
                                         : DlColor::kBlue());
  
       recorder_builder.DrawRect(rect, paint);
     }
   }
   auto texture =
       DisplayListToTexture(recorder_builder.Build(), {100, 100}, renderer);
  
   auto image_source = DlColorSource::MakeImage(
       DlImageImpeller::Make(texture), DlTileMode::kRepeat, DlTileMode::kRepeat);
   auto blur_filter = DlImageFilter::MakeBlur(5, 5, DlTileMode::kDecal);
  
   DlPaint paint;
   paint.setColor(DlColor::kDarkGreen());
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 300, 600), paint);
  
   paint.setColorSource(image_source);
   builder.DrawRect(DlRect::MakeLTRB(100, 100, 200, 200), paint);
  
   paint.setColorSource(nullptr);
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeLTRB(300, 0, 600, 600), paint);
  
   paint.setColorSource(image_source);
   paint.setImageFilter(blur_filter);
   builder.DrawRect(DlRect::MakeLTRB(400, 100, 500, 200), paint);
  
   paint.setImageFilter(nullptr);
   paint_lines(0, 300, paint);
  
   paint.setImageFilter(blur_filter);
   paint_lines(300, 300, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::saturated::b, impeller::DisplayListToTexture(), impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [16/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanConvertTriangleFanToTriangles
	)

Definition at line 157 of file aiks_dl_vertices_unittests.cc.

                                                    {
   constexpr Scalar hexagon_radius = 125;
   auto hex_start = Point(200.0, -hexagon_radius + 200.0);
   auto center_to_flat = 1.73 / 2 * hexagon_radius;
  
   // clang-format off
   std::vector<DlPoint> vertices = {
     DlPoint(hex_start.x, hex_start.y),
     DlPoint(hex_start.x + center_to_flat, hex_start.y + 0.5 * hexagon_radius),
     DlPoint(hex_start.x + center_to_flat, hex_start.y + 1.5 * hexagon_radius),
     DlPoint(hex_start.x + center_to_flat, hex_start.y + 1.5 * hexagon_radius),
     DlPoint(hex_start.x, hex_start.y + 2 * hexagon_radius),
     DlPoint(hex_start.x, hex_start.y + 2 * hexagon_radius),
     DlPoint(hex_start.x - center_to_flat, hex_start.y + 1.5 * hexagon_radius),
     DlPoint(hex_start.x - center_to_flat, hex_start.y + 1.5 * hexagon_radius),
     DlPoint(hex_start.x - center_to_flat, hex_start.y + 0.5 * hexagon_radius)
   };
   // clang-format on
   auto paint = flutter::DlPaint(flutter::DlColor::kDarkGrey());
   auto dl_vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangleFan, vertices.size(), vertices.data(),
       nullptr, nullptr);
   flutter::DisplayListBuilder builder;
   builder.DrawVertices(dl_vertices, flutter::DlBlendMode::kSrcOver, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [17/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawAnOpenPath
	)

Definition at line 428 of file aiks_dl_path_unittests.cc.

                                     {
   DisplayListBuilder builder;
  
   // Starting at (50, 50), draw lines from:
   // 1. (50, height)
   // 2. (width, height)
   // 3. (width, 50)
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(50, 50));
   path_builder.LineTo(DlPoint(50, 100));
   path_builder.LineTo(DlPoint(100, 100));
   path_builder.LineTo(DlPoint(100, 50));
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(10);
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [18/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawAnOpenPathThatIsntARect
	)

Definition at line 451 of file aiks_dl_path_unittests.cc.

                                                  {
   DisplayListBuilder builder;
  
   // Draw a stroked path that is explicitly closed to verify
   // It doesn't become a rectangle.
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(50, 50));
   path_builder.LineTo(DlPoint(520, 120));
   path_builder.LineTo(DlPoint(300, 310));
   path_builder.LineTo(DlPoint(100, 50));
   path_builder.Close();
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(10);
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [19/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawMultiContourConvexPath
	)

Definition at line 811 of file aiks_dl_path_unittests.cc.

                                                 {
   DlPathBuilder path_builder;
   for (auto i = 0; i < 10; i++) {
     if (i % 2 == 0) {
       // We use the factory method to convert the circle to a path so that it
       // uses the legacy conics for legacy golden output.
       DlPath circle =
           DlPath::MakeCircle(DlPoint(100 + 50 * i, 100 + 50 * i), 100);
       path_builder.AddPath(circle);
       path_builder.Close();
     } else {
       path_builder.MoveTo(DlPoint(100.f + 50.f * i - 100, 100.f + 50.f * i));
       path_builder.LineTo(DlPoint(100.f + 50.f * i, 100.f + 50.f * i - 100));
       path_builder.LineTo(DlPoint(100.f + 50.f * i - 100,  //
                                   100.f + 50.f * i - 100));
       path_builder.Close();
     }
   }
   DlPath path = path_builder.TakePath();
  
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed().withAlpha(102));
   builder.DrawPath(path, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [20/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaint
	)

Definition at line 404 of file aiks_dl_basic_unittests.cc.

                                {
   auto medium_turquoise =
       DlColor::RGBA(72.0f / 255.0f, 209.0f / 255.0f, 204.0f / 255.0f, 1.0f);
  
   DisplayListBuilder builder;
   builder.Scale(0.2, 0.2);
   builder.DrawPaint(DlPaint().setColor(medium_turquoise));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [21/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintMultipleTimes
	)

Definition at line 414 of file aiks_dl_basic_unittests.cc.

                                             {
   auto medium_turquoise =
       DlColor::RGBA(72.0f / 255.0f, 209.0f / 255.0f, 204.0f / 255.0f, 1.0f);
   auto orange_red =
       DlColor::RGBA(255.0f / 255.0f, 69.0f / 255.0f, 0.0f / 255.0f, 1.0f);
  
   DisplayListBuilder builder;
   builder.Scale(0.2, 0.2);
   builder.DrawPaint(DlPaint().setColor(medium_turquoise));
   builder.DrawPaint(DlPaint().setColor(orange_red.modulateOpacity(0.5f)));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [22/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintMultipleTimesInteractive
	)

Definition at line 682 of file aiks_dl_blend_unittests.cc.

                                                        {
   auto modes = GetBlendModeSelection();
  
   auto callback = [&]() -> sk_sp<DisplayList> {
     static Color background = Color::MediumTurquoise();
     static Color foreground = Color::Color::OrangeRed().WithAlpha(0.5);
     static int current_blend_index = 3;
  
     if (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();
     }
  
     DisplayListBuilder builder;
     builder.Scale(0.2, 0.2);
     DlPaint paint;
     paint.setColor(DlColor(background.ToARGB()));
     builder.DrawPaint(paint);
  
     paint.setColor(DlColor(foreground.ToARGB()));
     paint.setBlendMode(static_cast<DlBlendMode>(current_blend_index));
     builder.DrawPaint(paint);
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References GetBlendModeSelection(), impeller::AiksPlayground::ImGuiBegin(), impeller::Color::MediumTurquoise(), impeller::Color::ToARGB(), and impeller::Color::WithAlpha().

◆ TEST_P() [23/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintWithAdvancedBlend
	)

Definition at line 107 of file aiks_dl_blend_unittests.cc.

                                                 {
   DisplayListBuilder builder;
  
   builder.Scale(0.2, 0.2);
   DlPaint paint;
   paint.setColor(DlColor::RGBA(
       Color::MediumTurquoise().red, Color::MediumTurquoise().green,
       Color::MediumTurquoise().blue, Color::MediumTurquoise().alpha));
   builder.DrawPaint(paint);
  
   paint.setColor(DlColor::RGBA(Color::OrangeRed().red, Color::OrangeRed().green,
                                Color::OrangeRed().blue, 0.5));
   paint.setBlendMode(DlBlendMode::kHue);
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::Color::MediumTurquoise(), and impeller::Color::OrangeRed().

◆ TEST_P() [24/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPerspectiveTransformWithClips
	)

Definition at line 1307 of file aiks_dl_basic_unittests.cc.

                                                        {
   // Avoiding `GetSecondsElapsed()` to reduce risk of golden flakiness.
   int time = 0;
   auto callback = [&]() -> sk_sp<DisplayList> {
     DisplayListBuilder builder;
  
     builder.Save();
     {
       builder.Translate(300, 300);
  
       // 1. Draw/restore a clip before drawing the image, which will get drawn
       //    to the depth buffer behind the image.
       builder.Save();
       {
         DlPaint paint;
         paint.setColor(DlColor::kGreen());
         builder.DrawPaint(paint);
         builder.ClipRect(DlRect::MakeLTRB(-180, -180, 180, 180),
                          DlClipOp::kDifference);
  
         paint.setColor(DlColor::kBlack());
         builder.DrawPaint(paint);
       }
       builder.Restore();  // Restore rectangle difference clip.
  
       builder.Save();
       {
         // 2. Draw an oval clip that applies to the image, which will get drawn
         //    in front of the image on the depth buffer.
         builder.ClipOval(DlRect::MakeLTRB(-200, -200, 200, 200));
  
         Matrix result =
             Matrix(1.0, 0.0, 0.0, 0.0,    //
                    0.0, 1.0, 0.0, 0.0,    //
                    0.0, 0.0, 1.0, 0.003,  //
                    0.0, 0.0, 0.0, 1.0) *
             Matrix::MakeRotationY({Radians{-1.0f + (time++ / 60.0f)}});
  
         // 3. Draw the rotating image with a perspective transform.
         builder.Transform(result);
  
         auto image =
             DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
         auto position =
             -DlPoint(image->GetSize().width, image->GetSize().height) * 0.5;
         builder.DrawImage(image, position, {});
       }
       builder.Restore();  // Restore oval intersect clip.
  
       // 4. Draw a semi-translucent blue circle atop all previous draws.
       DlPaint paint;
       paint.setColor(DlColor::kBlue().modulateOpacity(0.4));
       builder.DrawCircle(DlPoint(), 230, paint);
     }
     builder.Restore();  // Restore translation.
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DlImageImpeller::Make(), impeller::Matrix::MakeRotationY(), and impeller::Matrix::Transform().

◆ TEST_P() [25/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPoints
	)

Definition at line 405 of file aiks_dl_unittests.cc.

                                 {
   std::vector<DlPoint> points = {
       {0, 0},      //
       {100, 100},  //
       {100, 0},    //
       {0, 100},    //
       {0, 0},      //
       {48, 48},    //
       {52, 52},    //
   };
   DlPaint paint_round;
   paint_round.setColor(DlColor::kYellow().withAlpha(128));
   paint_round.setStrokeCap(DlStrokeCap::kRound);
   paint_round.setStrokeWidth(20);
  
   DlPaint paint_square;
   paint_square.setColor(DlColor::kYellow().withAlpha(128));
   paint_square.setStrokeCap(DlStrokeCap::kSquare);
   paint_square.setStrokeWidth(20);
  
   DlPaint background;
   background.setColor(DlColor::kBlack());
  
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
   builder.DrawPaint(background);
   builder.Translate(200, 200);
  
   builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                      paint_round);
   builder.Translate(150, 0);
   builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                      paint_square);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References points.

◆ TEST_P() [26/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPointsWithTextureMap
	)

Definition at line 441 of file aiks_dl_unittests.cc.

                                               {
   auto texture = DlImageImpeller::Make(
       CreateTextureForFixture("table_mountain_nx.png",
                               /*enable_mipmapping=*/true));
  
   std::vector<DlPoint> points = {
       {0, 0},      //
       {100, 100},  //
       {100, 0},    //
       {0, 100},    //
       {0, 0},      //
       {48, 48},    //
       {52, 52},    //
   };
  
   auto image_src =
       DlColorSource::MakeImage(texture, DlTileMode::kClamp, DlTileMode::kClamp);
  
   DlPaint paint_round;
   paint_round.setStrokeCap(DlStrokeCap::kRound);
   paint_round.setColorSource(image_src);
   paint_round.setStrokeWidth(200);
  
   DlPaint paint_square;
   paint_square.setStrokeCap(DlStrokeCap::kSquare);
   paint_square.setColorSource(image_src);
   paint_square.setStrokeWidth(200);
  
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
   builder.Translate(200, 200);
  
   builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                      paint_round);
   builder.Translate(150, 0);
   builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                      paint_square);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and points.

◆ TEST_P() [27/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawScaledPointsLargeScaleSmallRadius
	)

Definition at line 840 of file aiks_dl_unittests.cc.

                                                            {
   std::vector<DlPoint> point = {
       {0, 0},  //
   };
  
   DlPaint paint;
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(100 * 0.000001);
  
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
   builder.Translate(200, 200);
   builder.Scale(1000000, 1000000);
  
   builder.DrawPoints(DlPointMode::kPoints, point.size(), point.data(), paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [28/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawScaledPointsSmallScaleLargeRadius
	)

Definition at line 820 of file aiks_dl_unittests.cc.

                                                            {
   std::vector<DlPoint> point = {
       {0, 0},  //
   };
  
   DlPaint paint;
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(100 * 1000000);
  
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
   builder.Translate(200, 200);
   builder.Scale(0.000001, 0.000001);
  
   builder.DrawPoints(DlPointMode::kPoints, point.size(), point.data(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [29/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanEmptyPictureConvertToImage
	)

Definition at line 961 of file aiks_dl_unittests.cc.

                                                 {
   DisplayListBuilder recorder_builder;
  
   DisplayListBuilder builder;
   AiksContext renderer(GetContext(), nullptr);
  
   DlPaint paint;
   paint.setColor(DlColor::kTransparent());
   builder.DrawPaint(paint);
  
   auto result_image =
       DisplayListToTexture(builder.Build(), ISize{1000, 1000}, renderer);
   if (result_image) {
     recorder_builder.DrawImage(DlImageImpeller::Make(result_image), DlPoint(),
                                {});
  
     paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 0.2));
     recorder_builder.DrawRect(DlRect::MakeWH(1000, 1000), paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(recorder_builder.Build()));
 }

References impeller::DisplayListToTexture(), and impeller::DlImageImpeller::Make().

◆ TEST_P() [30/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformFullScreenMSAA
	)

Definition at line 1648 of file aiks_dl_basic_unittests.cc.

                                            {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawCircle(DlPoint(250, 250), 125, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [31/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSaveLayerWithBounds
	)

Definition at line 1669 of file aiks_dl_basic_unittests.cc.

                                                 {
   DisplayListBuilder builder;
  
   DlPaint save;
   save.setColor(DlColor::kBlack());
  
   DlRect save_bounds = DlRect::MakeXYWH(0, 0, 50, 50);
   builder.SaveLayer(save_bounds, &save);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), paint);
   paint.setColor(DlColor::kGreen());
   builder.DrawRect(DlRect::MakeXYWH(10, 10, 100, 100), paint);
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(20, 20, 100, 100), paint);
  
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [32/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated
	)

Definition at line 1570 of file aiks_dl_basic_unittests.cc.

                                                                          {
   DisplayListBuilder builder;
  
   DlPaint red;
   red.setColor(DlColor::kRed());
  
   DlPaint green;
   green.setColor(DlColor::kGreen());
  
   DlPaint blue;
   blue.setColor(DlColor::kBlue());
  
   DlPaint save;
   save.setColor(DlColor::kBlack().modulateOpacity(0.5));
  
   DlRect huge_bounds = DlRect::MakeXYWH(0, 0, 100000, 100000);
   builder.SaveLayer(huge_bounds, &save);
  
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
   builder.DrawRect(DlRect::MakeXYWH(10, 10, 100, 100), green);
   builder.DrawRect(DlRect::MakeXYWH(20, 20, 100, 100), blue);
  
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [33/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSkew
	)

Definition at line 1658 of file aiks_dl_basic_unittests.cc.

                                  {
   DisplayListBuilder builder;
  
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.Skew(2, 5);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [34/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanPictureConvertToImage
	)

Definition at line 934 of file aiks_dl_unittests.cc.

                                            {
   DisplayListBuilder recorder_canvas;
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0));
   recorder_canvas.DrawRect(DlRect::MakeXYWH(100.0, 100.0, 600, 600), paint);
   paint.setColor(DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0));
   recorder_canvas.DrawRect(DlRect::MakeXYWH(200.0, 200.0, 600, 600), paint);
  
   DisplayListBuilder canvas;
   AiksContext renderer(GetContext(), nullptr);
   paint.setColor(DlColor::kTransparent());
   canvas.DrawPaint(paint);
  
   auto image =
       DisplayListToTexture(recorder_canvas.Build(), {1000, 1000}, renderer);
   if (image) {
     canvas.DrawImage(DlImageImpeller::Make(image), DlPoint(), {});
     paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 0.2));
     canvas.DrawRect(DlRect::MakeWH(1000, 1000), paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(canvas.Build()));
 }

References impeller::DisplayListToTexture(), and impeller::DlImageImpeller::Make().

◆ TEST_P() [35/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderAdvancedBlendColorFilterWithSaveLayer
	)

Definition at line 61 of file aiks_dl_blend_unittests.cc.

                                                                  {
   DisplayListBuilder builder;
  
   DlRect layer_rect = DlRect::MakeXYWH(0, 0, 500, 500);
   builder.ClipRect(layer_rect);
  
   DlPaint save_paint;
   save_paint.setColorFilter(DlColorFilter::MakeBlend(
       DlColor::RGBA(0, 1, 0, 0.5), DlBlendMode::kDifference));
   builder.SaveLayer(layer_rect, &save_paint);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlack());
   builder.DrawPaint(paint);
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [36/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlur
	)

Definition at line 241 of file aiks_dl_blur_unittests.cc.

                                         {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kCornflowerBlue());
   builder.DrawCircle(DlPoint(100, 100), 50, paint);
  
   paint.setColor(DlColor::kGreenYellow());
   builder.DrawCircle(DlPoint(300, 200), 100, paint);
  
   paint.setColor(DlColor::kDarkMagenta());
   builder.DrawCircle(DlPoint(140, 170), 75, paint);
  
   paint.setColor(DlColor::kOrangeRed());
   builder.DrawCircle(DlPoint(180, 120), 100, paint);
  
   DlRoundRect rrect =
       DlRoundRect::MakeRectXY(DlRect::MakeLTRB(75, 50, 375, 275), 20, 20);
   builder.ClipRoundRect(rrect);
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kSrc);
   auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
   builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [37/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurHugeSigma
	)

Definition at line 351 of file aiks_dl_blur_unittests.cc.

                                                  {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kGreen());
   builder.DrawCircle(DlPoint(400, 400), 300, paint);
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kSrc);
  
   auto backdrop_filter =
       DlImageFilter::MakeBlur(999999, 999999, DlTileMode::kClamp);
   builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [38/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurInteractive
	)

Definition at line 204 of file aiks_dl_blur_unittests.cc.

                                                    {
   auto callback = [&]() -> sk_sp<DisplayList> {
     static PlaygroundPoint point_a(Point(50, 50), 30, Color::White());
     static PlaygroundPoint point_b(Point(300, 200), 30, Color::White());
     auto [a, b] = DrawPlaygroundLine(point_a, point_b);
  
     DisplayListBuilder builder;
     DlPaint paint;
     paint.setColor(DlColor::kCornflowerBlue());
     builder.DrawCircle(DlPoint(100, 100), 50, paint);
  
     paint.setColor(DlColor::kGreenYellow());
     builder.DrawCircle(DlPoint(300, 200), 100, paint);
  
     paint.setColor(DlColor::kDarkMagenta());
     builder.DrawCircle(DlPoint(140, 170), 75, paint);
  
     paint.setColor(DlColor::kOrangeRed());
     builder.DrawCircle(DlPoint(180, 120), 100, paint);
  
     DlRoundRect rrect =
         DlRoundRect::MakeRectXY(DlRect::MakeLTRB(a.x, a.y, b.x, b.y), 20, 20);
     builder.ClipRoundRect(rrect);
  
     DlPaint save_paint;
     save_paint.setBlendMode(DlBlendMode::kSrc);
  
     auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
     builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
     builder.Restore();
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::saturated::b, impeller::DrawPlaygroundLine(), and impeller::Color::White().

◆ TEST_P() [39/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurWithSingleBackdropId
	)

Definition at line 270 of file aiks_dl_blur_unittests.cc.

                                                             {
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   DisplayListBuilder builder;
  
   DlPaint paint;
   builder.DrawImage(image, DlPoint(50.0, 50.0),
                     DlImageSampling::kNearestNeighbor, &paint);
  
   DlRoundRect rrect =
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(50, 250, 100, 100), 20, 20);
   builder.Save();
   builder.ClipRoundRect(rrect);
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kSrc);
   auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
   builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                     /*backdrop_id=*/1);
   builder.Restore();
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [40/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedBackdropFilter
	)

Definition at line 1268 of file aiks_dl_basic_unittests.cc.

                                                  {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   // Draw something interesting in the background.
   std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                  DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0)};
   std::vector<Scalar> stops = {
       0.0,
       1.0,
   };
   DlPaint paint;
   paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/DlPoint(0, 0),     //
       /*end_point=*/DlPoint(100, 100),   //
       /*stop_count=*/2,                  //
       /*colors=*/colors.data(),          //
       /*stops=*/stops.data(),            //
       /*tile_mode=*/DlTileMode::kRepeat  //
       ));
  
   builder.DrawPaint(paint);
  
   DlRect clip_rect = DlRect::MakeLTRB(50, 50, 400, 300);
   DlRoundRect clip_rrect = DlRoundRect::MakeRectXY(clip_rect, 100, 100);
  
   // Draw a clipped SaveLayer, where the clip coverage and SaveLayer size are
   // the same.
   builder.ClipRoundRect(clip_rrect, DlClipOp::kIntersect);
  
   DlPaint save_paint;
   auto backdrop_filter = DlImageFilter::MakeColorFilter(
       DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kExclusion));
   builder.SaveLayer(clip_rect, &save_paint, backdrop_filter.get());
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [41/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedBlur
	)

Definition at line 369 of file aiks_dl_blur_unittests.cc.

                                        {
   DisplayListBuilder builder;
   builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
  
   DlPaint paint;
   paint.setColor(DlColor::kGreen());
   paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
   builder.DrawCircle(DlPoint(400, 400), 200, paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [42/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedLayers
	)

Definition at line 1903 of file aiks_dl_basic_unittests.cc.

                                          {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   // Draw a green circle on the screen.
   {
     // Increase the clip depth for the savelayer to contend with.
     DlPath path = DlPath::MakeCircle(DlPoint(100, 100), 50);
     builder.ClipPath(path);
  
     DlRect bounds = DlRect::MakeXYWH(50, 50, 100, 100);
     DlPaint save_paint;
     builder.SaveLayer(bounds, &save_paint);
  
     // Fill the layer with white.
     paint.setColor(DlColor::kWhite());
     builder.DrawRect(DlRect::MakeSize(DlSize(400, 400)), paint);
     // Fill the layer with green, but do so with a color blend that can't be
     // collapsed into the parent pass.
     paint.setColor(DlColor::kGreen());
     paint.setBlendMode(DlBlendMode::kHardLight);
     builder.DrawRect(DlRect::MakeSize(DlSize(400, 400)), paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [43/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedRuntimeEffects
	)

Definition at line 39 of file aiks_dl_runtime_effect_unittests.cc.

                                                  {
   struct FragUniforms {
     Vector2 iResolution;
     Scalar iTime;
   } frag_uniforms = {.iResolution = Vector2(400, 400), .iTime = 100.0};
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(FragUniforms));
   memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
  
   DlPaint paint;
   paint.setColorSource(
       MakeRuntimeEffect(this, "runtime_stage_example.frag.iplr", uniform_data));
  
   DisplayListBuilder builder;
   builder.Save();
   builder.ClipRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 400, 400), 10.0, 10.0),
       DlClipOp::kIntersect);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [44/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClips
	)

Definition at line 864 of file aiks_dl_path_unittests.cc.

                                  {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kFuchsia());
  
   builder.ClipPath(DlPath::MakeRect(DlRect::MakeXYWH(0, 0, 500, 500)));
   builder.DrawPath(DlPath::MakeCircle(DlPoint(500, 500), 250), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [45/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColoredRect
	)

Definition at line 30 of file aiks_dl_basic_unittests.cc.

                                        {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawPath(DlPath::MakeRectXYWH(100.0f, 100.0f, 100.0f, 100.0f), paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [46/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColorFilterWithInvertColors
	)

Definition at line 62 of file aiks_dl_basic_unittests.cc.

                                                        {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kSrcOver));
   paint.setInvertColors(true);
  
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [47/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColorFilterWithInvertColorsDrawPaint
	)

Definition at line 74 of file aiks_dl_basic_unittests.cc.

                                                                 {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kSrcOver));
   paint.setInvertColors(true);
  
   builder.DrawPaint(paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [48/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradient
	)

Definition at line 655 of file aiks_dl_gradient_unittests.cc.

                                            {
   Scalar size = 256;
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, size * 3, size * 3), paint);
   std::vector<DlColor> colors = {
       DlColor(Color::MakeRGBA8(0xF4, 0x43, 0x36, 0xFF).ToARGB()),
       DlColor(Color::MakeRGBA8(0xFF, 0xEB, 0x3B, 0xFF).ToARGB()),
       DlColor(Color::MakeRGBA8(0x4c, 0xAF, 0x50, 0xFF).ToARGB()),
       DlColor(Color::MakeRGBA8(0x21, 0x96, 0xF3, 0xFF).ToARGB())};
   std::vector<Scalar> stops = {0.0, 1.f / 3.f, 2.f / 3.f, 1.0};
   std::array<std::tuple<DlPoint, float, DlPoint, float>, 8> array{
       std::make_tuple(DlPoint(size / 2.f, size / 2.f), 0.f,
                       DlPoint(size / 2.f, size / 2.f), size / 2.f),
       std::make_tuple(DlPoint(size / 2.f, size / 2.f), size / 4.f,
                       DlPoint(size / 2.f, size / 2.f), size / 2.f),
       std::make_tuple(DlPoint(size / 4.f, size / 4.f), 0.f,
                       DlPoint(size / 2.f, size / 2.f), size / 2.f),
       std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 2.f,
                       DlPoint(size / 2.f, size / 2.f), 0),
       std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 4.f,
                       DlPoint(size / 2.f, size / 2.f), size / 2.f),
       std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 16.f,
                       DlPoint(size / 2.f, size / 2.f), size / 8.f),
       std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 8.f,
                       DlPoint(size / 2.f, size / 2.f), size / 16.f),
       std::make_tuple(DlPoint(size / 8.f, size / 8.f), size / 8.f,
                       DlPoint(size / 2.f, size / 2.f), size / 8.f),
   };
   for (int i = 0; i < 8; i++) {
     builder.Save();
     builder.Translate((i % 3) * size, i / 3 * size);
     paint.setColorSource(DlColorSource::MakeConical(
         /*start_center=*/std::get<2>(array[i]),
         /*start_radius=*/std::get<3>(array[i]),
         /*end_center=*/std::get<0>(array[i]),
         /*end_radius=*/std::get<1>(array[i]),
         /*stop_count=*/stops.size(),
         /*colors=*/colors.data(),
         /*stops=*/stops.data(),
         /*tile_mode=*/DlTileMode::kClamp));
     builder.DrawRect(DlRect::MakeXYWH(0, 0, size, size), paint);
     builder.Restore();
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [49/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradientWithDitheringEnabled
	)

Definition at line 174 of file aiks_dl_gradient_unittests.cc.

                                                                {
   CanRenderConicalGradientWithDithering(this);
 }

References CanRenderConicalGradientWithDithering().

◆ TEST_P() [50/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradientWithIncompleteStops
	)

Definition at line 316 of file aiks_dl_gradient_unittests.cc.

                                                               {
   CanRenderGradientWithIncompleteStops(this,
                                        DlColorSourceType::kConicalGradient);
 }

◆ TEST_P() [51/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderCurvedStrokes
	)

Definition at line 71 of file aiks_dl_path_unittests.cc.

                                          {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(25);
   paint.setDrawStyle(DlDrawStyle::kStroke);
  
   builder.DrawPath(DlPath::MakeCircle(DlPoint(500, 500), 250), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [52/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDestructiveSaveLayer
	)

Definition at line 383 of file aiks_dl_unittests.cc.

                                                 {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawPaint(paint);
   // Draw an empty savelayer with a destructive blend mode, which will replace
   // the entire red screen with fully transparent black, except for the green
   // circle drawn within the layer.
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kSrc);
   builder.SaveLayer(std::nullopt, &save_paint);
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kGreen());
   builder.DrawCircle(DlPoint(300, 300), 100, draw_paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [53/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferenceClips
	)

Definition at line 35 of file aiks_dl_clip_unittests.cc.

                                            {
   DisplayListBuilder builder;
   builder.Translate(400, 400);
  
   // Limit drawing to face circle with a clip.
   builder.ClipPath(DlPath::MakeCircle(DlPoint(0, 0), 200));
   builder.Save();
  
   // Cut away eyes/mouth using difference clips.
   builder.ClipPath(DlPath::MakeCircle(DlPoint(-100, -50), 30),
                    DlClipOp::kDifference);
   builder.ClipPath(DlPath::MakeCircle(DlPoint(100, -50), 30),
                    DlClipOp::kDifference);
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(-100, 50));
   path_builder.QuadraticCurveTo(DlPoint(0, 150), DlPoint(100, 50));
   builder.ClipPath(path_builder.TakePath(), DlClipOp::kDifference);
  
   // Draw a huge yellow rectangle to prove the clipping works.
   DlPaint paint;
   paint.setColor(DlColor::kYellow());
   builder.DrawRect(DlRect::MakeXYWH(-1000, -1000, 2000, 2000), paint);
  
   // Remove the difference clips and draw hair that partially covers the eyes.
   builder.Restore();
   paint.setColor(DlColor::kMaroon());
   DlPathBuilder path_builder_2;
   path_builder_2.MoveTo(DlPoint(200, -200));
   path_builder_2.LineTo(DlPoint(-200, -200));
   path_builder_2.LineTo(DlPoint(-200, -40));
   path_builder_2.CubicCurveTo(DlPoint(0, -40), DlPoint(0, -80),
                               DlPoint(200, -80));
  
   builder.DrawPath(path_builder_2.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [54/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferencePaths
	)

Definition at line 395 of file aiks_dl_path_unittests.cc.

                                            {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
  
   RoundingRadii radii = {
       .top_left = {50, 25},
       .top_right = {25, 50},
       .bottom_left = {25, 50},
       .bottom_right = {50, 25},
   };
   DlPathBuilder path_builder;
   DlRoundRect rrect =
       DlRoundRect::MakeRectRadii(DlRect::MakeXYWH(100, 100, 200, 200), radii);
   // We use the factory method to convert the rrect and circle to a path so
   // that they use the legacy conics for legacy golden output.
   path_builder.AddPath(DlPath::MakeRoundRect(rrect));
   path_builder.AddPath(DlPath::MakeCircle(DlPoint(200, 200), 50));
   path_builder.SetFillType(DlPathFillType::kOdd);
   DlPath path = path_builder.TakePath();
  
   builder.DrawImage(
       DlImageImpeller::Make(CreateTextureForFixture("boston.jpg")),
       DlPoint{10, 10}, {});
   builder.DrawPath(path, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and impeller::RoundingRadii::top_left.

◆ TEST_P() [55/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferentShapesWithSameColorSource
	)

Definition at line 351 of file aiks_dl_basic_unittests.cc.

                                                               {
   DisplayListBuilder builder;
   DlPaint paint;
  
   DlColor colors[2] = {
       DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
       DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0),
   };
   DlScalar stops[2] = {
       0.0,
       1.0,
   };
  
   paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/DlPoint(0, 0),     //
       /*end_point=*/DlPoint(100, 100),   //
       /*stop_count=*/2,                  //
       /*colors=*/colors,                 //
       /*stops=*/stops,                   //
       /*tile_mode=*/DlTileMode::kRepeat  //
       ));
  
   builder.Save();
   builder.Translate(100, 100);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), paint);
   builder.Restore();
  
   builder.Save();
   builder.Translate(100, 400);
   builder.DrawCircle(DlPoint(100, 100), 100, paint);
   builder.Restore();
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [56/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrame
	)

Definition at line 382 of file aiks_dl_text_unittests.cc.

                                           {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References kFontFixture, and RenderTextInCanvasSkia().

◆ TEST_P() [57/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrameWithAlpha
	)

Definition at line 410 of file aiks_dl_text_unittests.cc.

                                                    {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
       {.color = DlColor::kBlack().modulateOpacity(0.5)}));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References kFontFixture, and RenderTextInCanvasSkia().

◆ TEST_P() [58/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrameWithBlur
	)

Definition at line 394 of file aiks_dl_text_unittests.cc.

                                                   {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
       TextRenderOptions{
           .color = DlColor::kBlue(),
           .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)}));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::testing::TextRenderOptions::color, kFontFixture, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [59/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderFilledConicPaths
	)

Definition at line 159 of file aiks_dl_path_unittests.cc.

                                             {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kFill);
  
   DlPaint reference_paint;
   reference_paint.setColor(DlColor::kGreen());
   reference_paint.setDrawStyle(DlDrawStyle::kFill);
  
   DlPathBuilder path_builder;
   DlPathBuilder reference_builder;
  
   // weight of 1.0 is just a quadratic bezier
   path_builder.MoveTo(DlPoint(100, 100));
   path_builder.ConicCurveTo(DlPoint(150, 150), DlPoint(200, 100), 1.0f);
   reference_builder.MoveTo(DlPoint(300, 100));
   reference_builder.QuadraticCurveTo(DlPoint(350, 150), DlPoint(400, 100));
  
   // weight of sqrt(2)/2 is a circular section
   path_builder.MoveTo(DlPoint(100, 200));
   path_builder.ConicCurveTo(DlPoint(150, 250), DlPoint(200, 200), kSqrt2Over2);
   reference_builder.MoveTo(DlPoint(300, 200));
   auto magic = DlPathBuilder::kArcApproximationMagic;
   reference_builder.CubicCurveTo(DlPoint(300, 200) + DlPoint(50, 50) * magic,
                                  DlPoint(400, 200) + DlPoint(-50, 50) * magic,
                                  DlPoint(400, 200));
  
   // weight of .01 is nearly a straight line
   path_builder.MoveTo(DlPoint(100, 300));
   path_builder.ConicCurveTo(DlPoint(150, 350), DlPoint(200, 300), 0.01f);
   reference_builder.MoveTo(DlPoint(300, 300));
   reference_builder.LineTo(DlPoint(350, 300.5));
   reference_builder.LineTo(DlPoint(400, 300));
  
   // weight of 100.0 is nearly a triangle
   path_builder.MoveTo(DlPoint(100, 400));
   path_builder.ConicCurveTo(DlPoint(150, 450), DlPoint(200, 400), 100.0f);
   reference_builder.MoveTo(DlPoint(300, 400));
   reference_builder.LineTo(DlPoint(350, 450));
   reference_builder.LineTo(DlPoint(400, 400));
  
   builder.DrawPath(path_builder.TakePath(), paint);
   builder.DrawPath(reference_builder.TakePath(), reference_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::kSqrt2Over2, and x.

◆ TEST_P() [60/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderForegroundAdvancedBlendWithMaskBlur
	)

Definition at line 183 of file aiks_dl_blur_unittests.cc.

                                                                {
   // This case triggers the ForegroundAdvancedBlend path. The color filter
   // should apply to the color only, and respect the alpha mask.
   DisplayListBuilder builder;
   builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
  
   DlPaint paint;
   paint.setColor(
       DlColor::RGBA(128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f, 1.0f));
  
   Sigma sigma = Radius(20);
   paint.setMaskFilter(
       DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kColor));
   builder.DrawCircle(DlPoint(400, 400), 200, paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::Sigma::sigma.

◆ TEST_P() [61/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderForegroundBlendWithMaskBlur
	)

Definition at line 164 of file aiks_dl_blur_unittests.cc.

                                                        {
   // This case triggers the ForegroundPorterDuffBlend path. The color filter
   // should apply to the color only, and respect the alpha mask.
   DisplayListBuilder builder;
   builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
  
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
  
   Sigma sigma = Radius(20);
   paint.setMaskFilter(
       DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kSrc));
   builder.DrawCircle(DlPoint(400, 400), 200, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::Sigma::sigma.

◆ TEST_P() [62/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGradientDecalWithBackground
	)

Definition at line 703 of file aiks_dl_gradient_unittests.cc.

                                                        {
   std::vector<DlColor> colors = {
       DlColor(Color::MakeRGBA8(0xF4, 0x43, 0x36, 0xFF).ToARGB()),
       DlColor(Color::MakeRGBA8(0xFF, 0xEB, 0x3B, 0xFF).ToARGB()),
       DlColor(Color::MakeRGBA8(0x4c, 0xAF, 0x50, 0xFF).ToARGB()),
       DlColor(Color::MakeRGBA8(0x21, 0x96, 0xF3, 0xFF).ToARGB())};
   std::vector<Scalar> stops = {0.0, 1.f / 3.f, 2.f / 3.f, 1.0};
  
   std::array<std::shared_ptr<DlColorSource>, 3> color_sources = {
       DlColorSource::MakeLinear({0, 0}, {100, 100}, stops.size(), colors.data(),
                                 stops.data(), DlTileMode::kDecal),
       DlColorSource::MakeRadial({100, 100}, 100, stops.size(), colors.data(),
                                 stops.data(), DlTileMode::kDecal),
       DlColorSource::MakeSweep({100, 100}, 45, 135, stops.size(), colors.data(),
                                stops.data(), DlTileMode::kDecal),
   };
  
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 605, 205), paint);
   for (int i = 0; i < 3; i++) {
     builder.Save();
     builder.Translate(i * 200.0f, 0);
     paint.setColorSource(color_sources[i]);
     builder.DrawRect(DlRect::MakeLTRB(0, 0, 200, 200), paint);
     builder.Restore();
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [63/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGroupOpacity
	)

Definition at line 34 of file aiks_dl_opacity_unittests.cc.

                                         {
   DisplayListBuilder builder;
  
   DlPaint red;
   red.setColor(DlColor::kRed());
   DlPaint green;
   green.setColor(DlColor::kGreen().modulateOpacity(0.5));
   DlPaint blue;
   blue.setColor(DlColor::kBlue());
  
   DlPaint alpha;
   alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
  
   builder.SaveLayer(std::nullopt, &alpha);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
   builder.DrawRect(DlRect::MakeXYWH(200, 200, 100, 100), green);
   builder.DrawRect(DlRect::MakeXYWH(400, 400, 100, 100), blue);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [64/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGroupOpacityToSavelayer
	)

Definition at line 56 of file aiks_dl_opacity_unittests.cc.

                                                    {
   DisplayListBuilder builder;
  
   DlPaint red;
   red.setColor(DlColor::kRed());
  
   DlPaint alpha;
   alpha.setColor(DlColor::kRed().modulateOpacity(0.7));
  
   // Create a saveLayer that will forward its opacity to another
   // saveLayer, to verify that we correctly distribute opacity.
   DlRect bounds = DlRect::MakeLTRB(0, 0, 500, 500);
   builder.SaveLayer(bounds, &alpha);
   builder.SaveLayer(bounds, &alpha);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), red);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 450, 450), red);
   builder.Restore();
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [65/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderImage
	)

Definition at line 38 of file aiks_dl_basic_unittests.cc.

                                  {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
   builder.DrawImage(image, DlPoint(100.0, 100.0),
                     DlImageSampling::kNearestNeighbor, &paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [66/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderImageRect
	)

Definition at line 211 of file aiks_dl_basic_unittests.cc.

                                      {
   DisplayListBuilder builder;
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   DlISize image_half_size =
       DlISize(image->GetSize().width * 0.5f, image->GetSize().height * 0.5f);
  
   // Render the bottom right quarter of the source image in a stretched rect.
   auto source_rect = DlRect::MakeSize(image_half_size);
   source_rect =
       source_rect.Shift(image_half_size.width, image_half_size.height);
  
   builder.DrawImageRect(image, source_rect,
                         DlRect::MakeXYWH(100, 100, 600, 600),
                         DlImageSampling::kNearestNeighbor);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [67/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderInvertedImageWithColorFilter
	)

Definition at line 48 of file aiks_dl_basic_unittests.cc.

                                                         {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kSrcOver));
   paint.setInvertColors(true);
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   builder.DrawImage(image, DlPoint(100.0, 100.0),
                     DlImageSampling::kNearestNeighbor, &paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [68/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderItalicizedText
	)

Definition at line 362 of file aiks_dl_text_unittests.cc.

                                           {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "HomemadeApple.ttf"));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [69/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientClamp
	)

Definition at line 55 of file aiks_dl_gradient_unittests.cc.

                                                {
   CanRenderLinearGradient(this, DlTileMode::kClamp);
 }

◆ TEST_P() [70/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientDecal
	)

Definition at line 64 of file aiks_dl_gradient_unittests.cc.

                                                {
   CanRenderLinearGradient(this, DlTileMode::kDecal);
 }

◆ TEST_P() [71/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientDecalWithColorFilter
	)

Definition at line 68 of file aiks_dl_gradient_unittests.cc.

                                                               {
   DisplayListBuilder builder;
   Point scale = GetContentScale();
   builder.Scale(scale.x, scale.y);
   DlPaint paint;
   builder.Translate(100.0f, 0);
  
   std::vector<DlColor> colors = {
       DlColor(Color{0.9568, 0.2627, 0.2118, 1.0}.ToARGB()),
       DlColor(Color{0.1294, 0.5882, 0.9529, 0.0}.ToARGB())};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   paint.setColorSource(DlColorSource::MakeLinear(
       {0, 0}, {200, 200}, 2, colors.data(), stops.data(), DlTileMode::kDecal));
   // Overlay the gradient with 25% green. This should appear as the entire
   // rectangle being drawn with 25% green, including the border area outside the
   // decal gradient.
   paint.setColorFilter(DlColorFilter::MakeBlend(DlColor::kGreen().withAlpha(64),
                                                 DlBlendMode::kSrcOver));
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::Color::ToARGB(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [72/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsClamp
	)

Definition at line 361 of file aiks_dl_gradient_unittests.cc.

                                                          {
   CanRenderLinearGradientManyColors(this, DlTileMode::kClamp);
 }

◆ TEST_P() [73/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsDecal
	)

Definition at line 370 of file aiks_dl_gradient_unittests.cc.

                                                          {
   CanRenderLinearGradientManyColors(this, DlTileMode::kDecal);
 }

◆ TEST_P() [74/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsMirror
	)

Definition at line 367 of file aiks_dl_gradient_unittests.cc.

                                                           {
   CanRenderLinearGradientManyColors(this, DlTileMode::kMirror);
 }

◆ TEST_P() [75/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsRepeat
	)

Definition at line 364 of file aiks_dl_gradient_unittests.cc.

                                                           {
   CanRenderLinearGradientManyColors(this, DlTileMode::kRepeat);
 }

◆ TEST_P() [76/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsUnevenStops
	)

Definition at line 405 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(DlRect::MakeXYWH(0, 0, 600, 600), paint);
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::ToARGB(), and impeller::Matrix::vec.

◆ TEST_P() [77/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientMaskBlur
	)

Definition at line 453 of file aiks_dl_gradient_unittests.cc.

                                                   {
   DisplayListBuilder builder;
  
   std::vector<DlColor> colors = {
       DlColor::kRed(), DlColor::kWhite(), DlColor::kRed(), DlColor::kWhite(),
       DlColor::kRed(), DlColor::kWhite(), DlColor::kRed(), DlColor::kWhite(),
       DlColor::kRed(), DlColor::kWhite(), DlColor::kRed()};
   std::vector<Scalar> stops = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5,
                                0.6, 0.7, 0.8, 0.9, 1.0};
  
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
   paint.setColorSource(DlColorSource::MakeLinear(
       {200, 200}, {400, 400}, stops.size(), colors.data(), stops.data(),
       DlTileMode::kClamp));
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
  
   builder.DrawCircle(DlPoint(300, 300), 200, paint);
   builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [78/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientMirror
	)

Definition at line 61 of file aiks_dl_gradient_unittests.cc.

                                                 {
   CanRenderLinearGradient(this, DlTileMode::kMirror);
 }

◆ TEST_P() [79/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientRepeat
	)

Definition at line 58 of file aiks_dl_gradient_unittests.cc.

                                                 {
   CanRenderLinearGradient(this, DlTileMode::kRepeat);
 }

◆ TEST_P() [80/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWayManyColorsClamp
	)

Definition at line 401 of file aiks_dl_gradient_unittests.cc.

                                                             {
   CanRenderLinearGradientWayManyColors(this, DlTileMode::kClamp);
 }

◆ TEST_P() [81/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithDitheringEnabled
	)

Definition at line 108 of file aiks_dl_gradient_unittests.cc.

                                                               {
   CanRenderLinearGradientWithDithering(this);
 }

References CanRenderLinearGradientWithDithering().

◆ TEST_P() [82/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithIncompleteStops
	)

Definition at line 308 of file aiks_dl_gradient_unittests.cc.

                                                              {
   CanRenderGradientWithIncompleteStops(this,
                                        DlColorSourceType::kLinearGradient);
 }

◆ TEST_P() [83/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithOverlappingStopsClamp
	)

Definition at line 203 of file aiks_dl_gradient_unittests.cc.

                                                                    {
   CanRenderLinearGradientWithOverlappingStops(this, DlTileMode::kClamp);
 }

◆ TEST_P() [84/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMaskBlurHugeSigma
	)

Definition at line 152 of file aiks_dl_blur_unittests.cc.

                                              {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kGreen());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 99999));
   builder.DrawCircle(DlPoint(400, 400), 300, paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [85/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMultipleBackdropBlurWithSingleBackdropId
	)

Definition at line 295 of file aiks_dl_blur_unittests.cc.

                                                                     {
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   DisplayListBuilder builder;
  
   DlPaint paint;
   builder.DrawImage(image, DlPoint(50.0, 50.0),
                     DlImageSampling::kNearestNeighbor, &paint);
  
   for (int i = 0; i < 6; i++) {
     DlRoundRect rrect = DlRoundRect::MakeRectXY(
         DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
     builder.Save();
     builder.ClipRoundRect(rrect);
  
     DlPaint save_paint;
     save_paint.setBlendMode(DlBlendMode::kSrc);
     auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
     builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                       /*backdrop_id=*/1);
     builder.Restore();
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [86/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMultipleBackdropBlurWithSingleBackdropIdAndDistinctFilters
	)

Definition at line 322 of file aiks_dl_blur_unittests.cc.

                                                                             {
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   DisplayListBuilder builder;
  
   DlPaint paint;
   builder.DrawImage(image, DlPoint(50.0, 50.0),
                     DlImageSampling::kNearestNeighbor, &paint);
  
   for (int i = 0; i < 6; i++) {
     DlRoundRect rrect = DlRoundRect::MakeRectXY(
         DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
     builder.Save();
     builder.ClipRoundRect(rrect);
  
     DlPaint save_paint;
     save_paint.setBlendMode(DlBlendMode::kSrc);
     auto backdrop_filter =
         DlImageFilter::MakeBlur(30 + i, 30, DlTileMode::kClamp);
     builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                       /*backdrop_id=*/1);
     builder.Restore();
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [87/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMultipleBackdropBlurWithSingleBackdropIdDifferentLayers
	)

Definition at line 1308 of file aiks_dl_blur_unittests.cc.

                                                                          {
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   DisplayListBuilder builder;
  
   DlPaint paint;
   builder.DrawImage(image, DlPoint(50.0, 50.0),
                     DlImageSampling::kNearestNeighbor, &paint);
  
   for (int i = 0; i < 6; i++) {
     if (i != 0) {
       DlPaint paint;
       paint.setColor(DlColor::kWhite().withAlphaF(0.95));
       builder.SaveLayer(std::nullopt, &paint);
     }
     DlRoundRect rrect = DlRoundRect::MakeRectXY(
         DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
     builder.Save();
     builder.ClipRoundRect(rrect);
  
     DlPaint save_paint;
     save_paint.setBlendMode(DlBlendMode::kSrc);
     auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
     builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                       /*backdrop_id=*/1);
     builder.Restore();
     builder.Restore();
     if (i != 0) {
       builder.Restore();
     }
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [88/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderNestedClips
	)

Definition at line 20 of file aiks_dl_clip_unittests.cc.

                                        {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kFuchsia());
  
   builder.Save();
   builder.ClipPath(DlPath::MakeCircle(DlPoint(200, 400), 300));
   builder.Restore();
   builder.ClipPath(DlPath::MakeCircle(DlPoint(600, 400), 300));
   builder.ClipPath(DlPath::MakeCircle(DlPoint(400, 600), 300));
   builder.DrawRect(DlRect::MakeXYWH(200, 200, 400, 400), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [89/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderOverlappingMultiContourPath
	)

Definition at line 914 of file aiks_dl_path_unittests.cc.

                                                        {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
  
   RoundingRadii radii = {
       .top_left = DlSize(50, 50),
       .top_right = DlSize(50, 50),
       .bottom_left = DlSize(50, 50),
       .bottom_right = DlSize(50, 50),
   };
  
   const Scalar kTriangleHeight = 100;
   DlRoundRect rrect = DlRoundRect::MakeRectRadii(
       DlRect::MakeXYWH(-kTriangleHeight / 2.0f, -kTriangleHeight / 2.0f,
                        kTriangleHeight, kTriangleHeight),
       radii  //
   );
   // We use the factory method to convert the rrect to a path so that it
   // uses the legacy conics for legacy golden output.
   DlPath rrect_path = DlPath::MakeRoundRect(rrect);
  
   builder.Translate(200, 200);
   // Form a path similar to the Material drop slider value indicator. Both
   // shapes should render identically side-by-side.
   {
     DlPathBuilder path_builder;
     path_builder.MoveTo(DlPoint(0, kTriangleHeight));
     path_builder.LineTo(DlPoint(-kTriangleHeight / 2.0f, 0));
     path_builder.LineTo(DlPoint(kTriangleHeight / 2.0f, 0));
     path_builder.Close();
     path_builder.AddPath(rrect_path);
  
     builder.DrawPath(path_builder.TakePath(), paint);
   }
   builder.Translate(100, 0);
  
   {
     DlPathBuilder path_builder;
     path_builder.MoveTo(DlPoint(0, kTriangleHeight));
     path_builder.LineTo(DlPoint(-kTriangleHeight / 2.0f, 0));
     path_builder.LineTo(DlPoint(0, -10));
     path_builder.LineTo(DlPoint(kTriangleHeight / 2.0f, 0));
     path_builder.Close();
     path_builder.AddPath(rrect_path);
  
     builder.DrawPath(path_builder.TakePath(), paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::RoundingRadii::top_left.

◆ TEST_P() [90/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderQuadraticStrokeWithInstantTurn
	)

Definition at line 139 of file aiks_dl_path_unittests.cc.

                                                           {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(50);
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeCap(DlStrokeCap::kRound);
  
   // Should draw a diagonal pill shape. If flat on either end, the stroke is
   // rendering wrong.
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(250, 250));
   path_builder.QuadraticCurveTo(DlPoint(100, 100), DlPoint(250, 250));
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [91/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradient
	)

Definition at line 476 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(DlRect::MakeXYWH(0, 0, 600, 600), paint);
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::ToARGB(), and impeller::Matrix::vec.

◆ TEST_P() [92/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientManyColors
	)

Definition at line 516 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(DlRect::MakeXYWH(0, 0, 600, 600), paint);
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::ToARGB(), and impeller::Matrix::vec.

◆ TEST_P() [93/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientWithDitheringEnabled
	)

Definition at line 128 of file aiks_dl_gradient_unittests.cc.

                                                               {
   CanRenderRadialGradientWithDithering(this);
 }

References CanRenderRadialGradientWithDithering().

◆ TEST_P() [94/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientWithIncompleteStops
	)

Definition at line 312 of file aiks_dl_gradient_unittests.cc.

                                                              {
   CanRenderGradientWithIncompleteStops(this,
                                        DlColorSourceType::kRadialGradient);
 }

◆ TEST_P() [95/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRoundedRectWithNonUniformRadii
	)

Definition at line 385 of file aiks_dl_basic_unittests.cc.

                                                           {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
  
   RoundingRadii radii = {
       .top_left = DlSize(50, 25),
       .top_right = DlSize(25, 50),
       .bottom_left = DlSize(25, 50),
       .bottom_right = DlSize(50, 25),
   };
   DlRoundRect rrect =
       DlRoundRect::MakeRectRadii(DlRect::MakeXYWH(100, 100, 500, 500), radii);
  
   builder.DrawRoundRect(rrect, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::RoundingRadii::top_left.

◆ TEST_P() [96/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRuntimeEffectFilter
	)

Definition at line 84 of file aiks_dl_runtime_effect_unittests.cc.

                                                {
   auto runtime_stages =
       OpenAssetAsRuntimeStage("runtime_stage_filter_example.frag.iplr");
  
   std::shared_ptr<RuntimeStage> runtime_stage =
       runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
   ASSERT_TRUE(runtime_stage);
   ASSERT_TRUE(runtime_stage->IsDirty());
  
   std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
       nullptr,
   };
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(Vector2));
  
   DlPaint paint;
   paint.setColor(DlColor::kAqua());
   paint.setImageFilter(DlImageFilter::MakeRuntimeEffect(
       DlRuntimeEffect::MakeImpeller(runtime_stage), sampler_inputs,
       uniform_data));
  
   DisplayListBuilder builder;
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [97/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSimpleClips
	)

Definition at line 249 of file aiks_dl_basic_unittests.cc.

                                        {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
  
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   auto draw = [&builder](const DlPaint& paint, Scalar x, Scalar y) {
     builder.Save();
     builder.Translate(x, y);
     {
       builder.Save();
       builder.ClipRect(DlRect::MakeLTRB(50, 50, 150, 150));
       builder.DrawPaint(paint);
       builder.Restore();
     }
     {
       builder.Save();
       builder.ClipOval(DlRect::MakeLTRB(200, 50, 300, 150));
       builder.DrawPaint(paint);
       builder.Restore();
     }
     {
       builder.Save();
       builder.ClipRoundRect(
           DlRoundRect::MakeRectXY(DlRect::MakeLTRB(50, 200, 150, 300), 20, 20));
       builder.DrawPaint(paint);
       builder.Restore();
     }
     {
       builder.Save();
       builder.ClipRoundRect(DlRoundRect::MakeRectXY(
           DlRect::MakeLTRB(200, 230, 300, 270), 20, 20));
       builder.DrawPaint(paint);
       builder.Restore();
     }
     {
       builder.Save();
       builder.ClipRoundRect(DlRoundRect::MakeRectXY(
           DlRect::MakeLTRB(230, 200, 270, 300), 20, 20));
       builder.DrawPaint(paint);
       builder.Restore();
     }
     builder.Restore();
   };
  
   paint.setColor(DlColor::kBlue());
   draw(paint, 0, 0);
  
   DlColor gradient_colors[7] = {
       DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
       DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
   };
   Scalar stops[7] = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
   auto image = DlImageImpeller::Make(texture);
  
   paint.setColorSource(DlColorSource::MakeRadial(
       DlPoint(500, 600), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
   draw(paint, 0, 300);
  
   paint.setColorSource(
       DlColorSource::MakeImage(image, DlTileMode::kRepeat, DlTileMode::kRepeat,
                                DlImageSampling::kNearestNeighbor));
   draw(paint, 300, 0);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [98/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokedConicPaths
	)

Definition at line 209 of file aiks_dl_path_unittests.cc.

                                              {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(10);
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setStrokeJoin(DlStrokeJoin::kRound);
  
   DlPaint reference_paint;
   reference_paint.setColor(DlColor::kGreen());
   reference_paint.setStrokeWidth(10);
   reference_paint.setDrawStyle(DlDrawStyle::kStroke);
   reference_paint.setStrokeCap(DlStrokeCap::kRound);
   reference_paint.setStrokeJoin(DlStrokeJoin::kRound);
  
   DlPathBuilder path_builder;
   DlPathBuilder reference_builder;
  
   // weight of 1.0 is just a quadratic bezier
   path_builder.MoveTo(DlPoint(100, 100));
   path_builder.ConicCurveTo(DlPoint(150, 150), DlPoint(200, 100), 1.0f);
   reference_builder.MoveTo(DlPoint(300, 100));
   reference_builder.QuadraticCurveTo(DlPoint(350, 150), DlPoint(400, 100));
  
   // weight of sqrt(2)/2 is a circular section
   path_builder.MoveTo(DlPoint(100, 200));
   path_builder.ConicCurveTo(DlPoint(150, 250), DlPoint(200, 200), kSqrt2Over2);
   reference_builder.MoveTo(DlPoint(300, 200));
   auto magic = DlPathBuilder::kArcApproximationMagic;
   reference_builder.CubicCurveTo(DlPoint(300, 200) + DlPoint(50, 50) * magic,
                                  DlPoint(400, 200) + DlPoint(-50, 50) * magic,
                                  DlPoint(400, 200));
  
   // weight of .0 is a straight line
   path_builder.MoveTo(DlPoint(100, 300));
   path_builder.ConicCurveTo(DlPoint(150, 350), DlPoint(200, 300), 0.0f);
   reference_builder.MoveTo(DlPoint(300, 300));
   reference_builder.LineTo(DlPoint(400, 300));
  
   // weight of 100.0 is nearly a triangle
   path_builder.MoveTo(DlPoint(100, 400));
   path_builder.ConicCurveTo(DlPoint(150, 450), DlPoint(200, 400), 100.0f);
   reference_builder.MoveTo(DlPoint(300, 400));
   reference_builder.LineTo(DlPoint(350, 450));
   reference_builder.LineTo(DlPoint(400, 400));
  
   builder.DrawPath(path_builder.TakePath(), paint);
   builder.DrawPath(reference_builder.TakePath(), reference_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::kSqrt2Over2, and x.

◆ TEST_P() [99/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokedTextFrame
	)

Definition at line 126 of file aiks_dl_text_unittests.cc.

                                             {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf",
       {
           .stroke = true,
       }));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [100/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokePathThatEndsAtSharpTurn
	)

Definition at line 107 of file aiks_dl_path_unittests.cc.

                                                          {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(200);
   paint.setDrawStyle(DlDrawStyle::kStroke);
  
   DlPath path = DlPath::MakeArc(DlRect::MakeXYWH(100, 100, 200, 200),  //
                                 DlDegrees(0), DlDegrees(90), false);
  
   builder.DrawPath(path, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [101/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokePathWithCubicLine
	)

Definition at line 122 of file aiks_dl_path_unittests.cc.

                                                    {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(20);
   paint.setDrawStyle(DlDrawStyle::kStroke);
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(0, 200));
   path_builder.CubicCurveTo(DlPoint(50, 400), DlPoint(350, 0),
                             DlPoint(400, 200));
  
   builder.DrawPath(path_builder.TakePath(), paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [102/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokes
	)

Definition at line 58 of file aiks_dl_path_unittests.cc.

                                    {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(20);
   paint.setDrawStyle(DlDrawStyle::kStroke);
  
   builder.DrawPath(DlPath::MakeLine(DlPoint(200, 100), DlPoint(800, 100)),
                    paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [103/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientClamp
	)

Definition at line 595 of file aiks_dl_gradient_unittests.cc.

                                               {
   CanRenderSweepGradient(this, DlTileMode::kClamp);
 }

◆ TEST_P() [104/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientDecal
	)

Definition at line 604 of file aiks_dl_gradient_unittests.cc.

                                               {
   CanRenderSweepGradient(this, DlTileMode::kDecal);
 }

◆ TEST_P() [105/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsClamp
	)

Definition at line 642 of file aiks_dl_gradient_unittests.cc.

                                                         {
   CanRenderSweepGradientManyColors(this, DlTileMode::kClamp);
 }

◆ TEST_P() [106/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsDecal
	)

Definition at line 651 of file aiks_dl_gradient_unittests.cc.

                                                         {
   CanRenderSweepGradientManyColors(this, DlTileMode::kDecal);
 }

◆ TEST_P() [107/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsMirror
	)

Definition at line 648 of file aiks_dl_gradient_unittests.cc.

                                                          {
   CanRenderSweepGradientManyColors(this, DlTileMode::kMirror);
 }

◆ TEST_P() [108/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsRepeat
	)

Definition at line 645 of file aiks_dl_gradient_unittests.cc.

                                                          {
   CanRenderSweepGradientManyColors(this, DlTileMode::kRepeat);
 }

◆ TEST_P() [109/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientMirror
	)

Definition at line 601 of file aiks_dl_gradient_unittests.cc.

                                                {
   CanRenderSweepGradient(this, DlTileMode::kMirror);
 }

◆ TEST_P() [110/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientRepeat
	)

Definition at line 598 of file aiks_dl_gradient_unittests.cc.

                                                {
   CanRenderSweepGradient(this, DlTileMode::kRepeat);
 }

◆ TEST_P() [111/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientWithDitheringEnabled
	)

Definition at line 151 of file aiks_dl_gradient_unittests.cc.

                                                              {
   CanRenderSweepGradientWithDithering(this);
 }

References CanRenderSweepGradientWithDithering().

◆ TEST_P() [112/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientWithIncompleteStops
	)

Definition at line 320 of file aiks_dl_gradient_unittests.cc.

                                                             {
   CanRenderGradientWithIncompleteStops(this, DlColorSourceType::kSweepGradient);
 }

◆ TEST_P() [113/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrame
	)

Definition at line 97 of file aiks_dl_text_unittests.cc.

                                      {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf"));
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [114/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithFractionScaling
	)

Definition at line 251 of file aiks_dl_text_unittests.cc.

                                                         {
   Scalar fine_scale = 0.f;
   bool is_subpixel = false;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Fine Scale", &fine_scale, -1, 1);
       ImGui::Checkbox("subpixel", &is_subpixel);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     DlPaint paint;
     paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
     builder.DrawPaint(paint);
     Scalar scale = 2.625 + fine_scale;
     builder.Scale(scale, scale);
     RenderTextInCanvasSkia(GetContext(), builder,
                            "the quick brown fox jumped over the lazy dog!.?",
                            "Roboto-Regular.ttf",
                            TextRenderOptions{.is_subpixel = is_subpixel});
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::testing::TextRenderOptions::is_subpixel, is_subpixel, and RenderTextInCanvasSkia().

◆ TEST_P() [115/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithHalfScaling
	)

Definition at line 158 of file aiks_dl_text_unittests.cc.

                                                     {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
   builder.Scale(0.5, 0.5);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf"));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [116/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithInvertedTransform
	)

Definition at line 110 of file aiks_dl_text_unittests.cc.

                                                           {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
   builder.Translate(1000, 0);
   builder.Scale(-1, 1);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf"));
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [117/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithScalingOverflow
	)

Definition at line 222 of file aiks_dl_text_unittests.cc.

                                                         {
   Scalar scale = 60.0;
   Scalar offsetx = -500.0;
   Scalar offsety = 700.0;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("scale", &scale, 1.f, 300.f);
       ImGui::SliderFloat("offsetx", &offsetx, -600.f, 100.f);
       ImGui::SliderFloat("offsety", &offsety, 600.f, 2048.f);
       ImGui::End();
     }
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     DlPaint paint;
     paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
     builder.DrawPaint(paint);
     builder.Scale(scale, scale);
  
     RenderTextInCanvasSkia(
         GetContext(), builder, "test", "Roboto-Regular.ttf",
         TextRenderOptions{
             .position = DlPoint(offsetx / scale, offsety / scale),
         });
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::testing::TextRenderOptions::position, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [118/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextInSaveLayer
	)

Definition at line 423 of file aiks_dl_text_unittests.cc.

                                            {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(0.1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   builder.Translate(100, 100);
   builder.Scale(0.5, 0.5);
  
   // Blend the layer with the parent pass using kClear to expose the coverage.
   paint.setBlendMode(DlBlendMode::kClear);
   builder.SaveLayer(std::nullopt, &paint);
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf"));
   builder.Restore();
  
   // Render the text again over the cleared coverage rect.
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf"));
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [119/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextOutsideBoundaries
	)

Definition at line 449 of file aiks_dl_text_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   builder.Translate(200, 150);
  
   // Construct the text blob.
   auto mapping = flutter::testing::OpenFixtureAsSkData("wtf.otf");
   ASSERT_NE(mapping, nullptr);
  
   Scalar font_size = 80;
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   SkFont sk_font(font_mgr->makeFromData(mapping), font_size);
  
   DlPaint text_paint;
   text_paint.setColor(DlColor::kBlue().withAlpha(255 * 0.8));
  
   struct {
     DlPoint position;
     const char* text;
   } text[] = {{DlPoint(0, 0), "0F0F0F0"},
               {DlPoint(1, 2), "789"},
               {DlPoint(1, 3), "456"},
               {DlPoint(1, 4), "123"},
               {DlPoint(0, 6), "0F0F0F0"}};
   for (auto& t : text) {
     builder.Save();
     builder.Translate(t.position.x * font_size * 2,
                       t.position.y * font_size * 1.1);
     {
       auto blob = SkTextBlob::MakeFromString(t.text, sk_font);
       ASSERT_NE(blob, nullptr);
       auto frame = MakeTextFrameFromTextBlobSkia(blob);
       builder.DrawTextFrame(frame, 0, 0, text_paint);
     }
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References font_size, and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [120/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextStrokeWidth
	)

Definition at line 142 of file aiks_dl_text_unittests.cc.

                                            {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "LMNOP VWXYZ",
                                      "Roboto-Medium.ttf",
                                      {
                                          .stroke = true,
                                          .stroke_width = 4,
                                      }));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [121/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextWithLargePerspectiveTransform
	)

Definition at line 546 of file aiks_dl_text_unittests.cc.

                                                              {
   // Verifies that text scales are clamped to work around
   // https://github.com/flutter/flutter/issues/136112 .
  
   DisplayListBuilder builder;
  
   DlPaint save_paint;
   builder.SaveLayer(std::nullopt, &save_paint);
   builder.Transform(Matrix(2000, 0, 0, 0,   //
                            0, 2000, 0, 0,   //
                            0, 0, -1, 9000,  //
                            0, 0, -1, 7000   //
                            ));
  
   ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "Hello world",
                                      "Roboto-Regular.ttf"));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [122/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextWithPerspectiveTransformInSublist
	)

Definition at line 565 of file aiks_dl_text_unittests.cc.

                                                                  {
   DisplayListBuilder text_builder;
   ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), text_builder, "Hello world",
                                      "Roboto-Regular.ttf"));
   auto text_display_list = text_builder.Build();
  
   DisplayListBuilder builder;
  
   Matrix matrix = Matrix::MakeRow(2.0, 0.0, 0.0, 0.0,  //
                                   0.0, 2.0, 0.0, 0.0,  //
                                   0.0, 0.0, 1.0, 0.0,  //
                                   0.0, 0.002, 0.0, 1.0);
  
   DlPaint save_paint;
   DlRect window_bounds =
       DlRect::MakeXYWH(0, 0, GetWindowSize().width, GetWindowSize().height);
   builder.SaveLayer(window_bounds, &save_paint);
   builder.Transform(matrix);
   builder.DrawDisplayList(text_display_list, 1.0f);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [123/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThickCurvedStrokes
	)

Definition at line 83 of file aiks_dl_path_unittests.cc.

                                               {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(100);
   paint.setDrawStyle(DlDrawStyle::kStroke);
  
   builder.DrawPath(DlPath::MakeCircle(DlPoint(100, 100), 50), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [124/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThinCurvedStrokes
	)

Definition at line 95 of file aiks_dl_path_unittests.cc.

                                              {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setStrokeWidth(0.01);
   paint.setDrawStyle(DlDrawStyle::kStroke);
  
   builder.DrawPath(DlPath::MakeCircle(DlPoint(100, 100), 50), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [125/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTightConicPath
	)

Definition at line 346 of file aiks_dl_path_unittests.cc.

                                           {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kFill);
  
   DlPaint reference_paint;
   reference_paint.setColor(DlColor::kGreen());
   reference_paint.setDrawStyle(DlDrawStyle::kFill);
  
   DlPathBuilder path_builder;
  
   path_builder.MoveTo(DlPoint(100, 100));
   path_builder.ConicCurveTo(DlPoint(150, 450), DlPoint(200, 100), 5.0f);
  
   DlPathBuilder reference_builder;
   PathTessellator::Conic component{DlPoint(300, 100),  //
                                    DlPoint(350, 450),  //
                                    DlPoint(400, 100),  //
                                    5.0f};
   reference_builder.MoveTo(component.p1);
   constexpr int N = 100;
   for (int i = 1; i < N; i++) {
     reference_builder.LineTo(component.Solve(static_cast<Scalar>(i) / N));
   }
   reference_builder.LineTo(component.p2);
  
   DlPaint line_paint;
   line_paint.setColor(DlColor::kYellow());
   line_paint.setDrawStyle(DlDrawStyle::kStroke);
   line_paint.setStrokeWidth(1.0f);
  
   // Draw some lines to provide a spacial reference for the curvature of
   // the tips of the direct rendering and the manually tessellated versions.
   builder.DrawLine(DlPoint(145, 100), DlPoint(145, 450), line_paint);
   builder.DrawLine(DlPoint(155, 100), DlPoint(155, 450), line_paint);
   builder.DrawLine(DlPoint(345, 100), DlPoint(345, 450), line_paint);
   builder.DrawLine(DlPoint(355, 100), DlPoint(355, 450), line_paint);
   builder.DrawLine(DlPoint(100, 392.5f), DlPoint(400, 392.5f), line_paint);
  
   // Draw the two paths (direct and manually tessellated) on top of the lines.
   builder.DrawPath(path_builder.TakePath(), paint);
   builder.DrawPath(reference_builder.TakePath(), reference_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [126/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureClamp
	)

Definition at line 190 of file aiks_dl_basic_unittests.cc.

                                              {
   CanRenderTiledTexture(this, DlTileMode::kClamp);
 }

◆ TEST_P() [127/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureClampWithTranslate
	)

Definition at line 206 of file aiks_dl_basic_unittests.cc.

                                                           {
   CanRenderTiledTexture(this, DlTileMode::kClamp,
                         Matrix::MakeTranslation({172.f, 172.f, 0.f}));
 }

References impeller::Matrix::MakeTranslation().

◆ TEST_P() [128/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureDecal
	)

Definition at line 202 of file aiks_dl_basic_unittests.cc.

                                              {
   CanRenderTiledTexture(this, DlTileMode::kDecal);
 }

◆ TEST_P() [129/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureMirror
	)

Definition at line 198 of file aiks_dl_basic_unittests.cc.

                                               {
   CanRenderTiledTexture(this, DlTileMode::kMirror);
 }

◆ TEST_P() [130/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureRepeat
	)

Definition at line 194 of file aiks_dl_basic_unittests.cc.

                                               {
   CanRenderTiledTexture(this, DlTileMode::kRepeat);
 }

◆ TEST_P() [131/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTinyOverlappingSubpasses
	)

This is a regression check for https://github.com/flutter/engine/pull/41129 The entire screen is green if successful. If failing, no frames will render, or the entire screen will be transparent black.

Definition at line 358 of file aiks_dl_unittests.cc.

                                                     {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawPaint(paint);
  
   // Draw two overlapping subpixel circles.
   builder.SaveLayer(std::nullopt);
  
   DlPaint yellow_paint;
   yellow_paint.setColor(DlColor::kYellow());
   builder.DrawCircle(DlPoint(100, 100), 0.1, yellow_paint);
   builder.Restore();
   builder.SaveLayer(std::nullopt);
   builder.DrawCircle(DlPoint(100, 100), 0.1, yellow_paint);
   builder.Restore();
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kGreen());
   builder.DrawPaint(draw_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [132/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderWithContiguousClipRestores
	)

Definition at line 74 of file aiks_dl_clip_unittests.cc.

                                                       {
   DisplayListBuilder builder;
  
   // Cover the whole canvas with red.
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawPaint(paint);
  
   builder.Save();
  
   // Append two clips, the second resulting in empty coverage.
   builder.ClipRect(DlRect::MakeXYWH(100, 100, 100, 100));
   builder.ClipRect(DlRect::MakeXYWH(300, 300, 100, 100));
  
   // Restore to no clips.
   builder.Restore();
  
   // Replace the whole canvas with green.
   paint.setColor(DlColor::kGreen());
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [133/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanSaveLayerStandalone
	)

Definition at line 333 of file aiks_dl_basic_unittests.cc.

                                          {
   DisplayListBuilder builder;
  
   DlPaint red;
   red.setColor(DlColor::kRed());
  
   DlPaint alpha;
   alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
  
   builder.SaveLayer(std::nullopt, &alpha);
  
   builder.DrawCircle(DlPoint(125, 125), 125, red);
  
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [134/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanvasCanPushPopCTM
	)

Definition at line 111 of file canvas_unittests.cc.

                                       {
   ContentContext context(GetContext(), nullptr);
   auto canvas = CreateTestCanvas(context);
  
   ASSERT_EQ(canvas->GetSaveCount(), 1u);
   ASSERT_EQ(canvas->Restore(), false);
  
   canvas->Translate(Size{100, 100});
   canvas->Save(10);
   ASSERT_EQ(canvas->GetSaveCount(), 2u);
   ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(),
                      Matrix::MakeTranslation({100.0, 100.0, 0.0}));
   ASSERT_TRUE(canvas->Restore());
   ASSERT_EQ(canvas->GetSaveCount(), 1u);
   ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(),
                      Matrix::MakeTranslation({100.0, 100.0, 0.0}));
 }

References ASSERT_MATRIX_NEAR, CreateTestCanvas(), and impeller::Matrix::MakeTranslation().

◆ TEST_P() [135/545]

impeller::testing::TEST_P	(	AiksTest	,
		CanvasCTMCanBeUpdated
	)

Definition at line 129 of file canvas_unittests.cc.

                                         {
   ContentContext context(GetContext(), nullptr);
   auto canvas = CreateTestCanvas(context);
  
   Matrix identity;
   ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(), identity);
   canvas->Translate(Size{100, 100});
   ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(),
                      Matrix::MakeTranslation({100.0, 100.0, 0.0}));
 }

References ASSERT_MATRIX_NEAR, CreateTestCanvas(), and impeller::Matrix::MakeTranslation().

◆ TEST_P() [136/545]

impeller::testing::TEST_P	(	AiksTest	,
		ClearBlend
	)

Definition at line 485 of file aiks_dl_blend_unittests.cc.

                              {
   DisplayListBuilder builder;
  
   DlPaint blue;
   blue.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 600.0, 600.0), blue);
  
   DlPaint clear;
   clear.setBlendMode(DlBlendMode::kClear);
  
   builder.DrawCircle(DlPoint(300.0, 300.0), 200.0, clear);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [137/545]

impeller::testing::TEST_P	(	AiksTest	,
		ClearBlendWithBlur
	)

Definition at line 423 of file aiks_dl_blur_unittests.cc.

                                      {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 600.0, 600.0), paint);
  
   DlPaint clear;
   clear.setBlendMode(DlBlendMode::kClear);
   clear.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
  
   builder.DrawCircle(DlPoint(300.0, 300.0), 200.0, clear);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [138/545]

impeller::testing::TEST_P	(	AiksTest	,
		ClearColorOptimizationWhenSubpassIsBiggerThanParentPass
	)

Definition at line 1514 of file aiks_dl_basic_unittests.cc.

                                                                           {
   SetWindowSize({400, 400});
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeLTRB(200, 200, 300, 300), paint);
  
   paint.setImageFilter(DlImageFilter::MakeMatrix(DlMatrix::MakeScale({2, 2, 1}),
                                                  DlImageSampling::kLinear));
   builder.SaveLayer(std::nullopt, &paint);
   // Draw a rectangle that would fully cover the parent pass size, but not
   // the subpass that it is rendered in.
   paint.setColor(DlColor::kGreen());
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 400), paint);
   // Draw a bigger rectangle to force the subpass to be bigger.
  
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 800, 800), paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [139/545]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBlurFilterRendersCorrectly
	)

Definition at line 406 of file aiks_dl_blur_unittests.cc.

                                                     {
   DisplayListBuilder builder;
   builder.Translate(0, -400);
   DlPaint paint;
  
   Sigma sigma = Radius{120 * 3};
   paint.setMaskFilter(
       DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
   paint.setColor(DlColor::kRed());
  
   DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 800, 800));
   path = path + DlPath::MakeCircle(DlPoint(0, 0), 0.5);
   builder.DrawPath(path, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::Sigma::sigma.

◆ TEST_P() [140/545]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBlurFilterRendersCorrectlyInteractive
	)

Definition at line 382 of file aiks_dl_blur_unittests.cc.

                                                                {
   auto callback = [&]() -> sk_sp<DisplayList> {
     static PlaygroundPoint playground_point(Point(400, 400), 20,
                                             Color::Green());
     auto point = DrawPlaygroundPoint(playground_point);
  
     DisplayListBuilder builder;
     auto location = point - Point(400, 400);
     builder.Translate(location.x, location.y);
  
     DlPaint paint;
     Sigma sigma = Radius{120 * 3};
     paint.setMaskFilter(
         DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
     paint.setColor(DlColor::kRed());
  
     DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 800, 800));
     path = path + DlPath::MakeCircle(DlPoint(0, 0), 0.5);
     builder.DrawPath(path, paint);
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundPoint(), impeller::Color::Green(), and impeller::Sigma::sigma.

◆ TEST_P() [141/545]

impeller::testing::TEST_P	(	AiksTest	,
		ClipsUseCurrentTransform
	)

Definition at line 98 of file aiks_dl_clip_unittests.cc.

                                            {
   std::array<DlColor, 5> colors = {DlColor::kWhite(), DlColor::kBlack(),
                                    DlColor::kSkyBlue(), DlColor::kRed(),
                                    DlColor::kYellow()};
   DisplayListBuilder builder;
   DlPaint paint;
  
   builder.Translate(300, 300);
   for (int i = 0; i < 15; i++) {
     builder.Scale(0.8, 0.8);
  
     paint.setColor(colors[i % colors.size()]);
     builder.ClipPath(DlPath::MakeCircle(DlPoint(0, 0), 300));
     builder.DrawRect(DlRect::MakeXYWH(-300, -300, 600, 600), paint);
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [142/545]

impeller::testing::TEST_P	(	AiksTest	,
		CollapsedDrawPaintInSubpass
	)

Definition at line 41 of file aiks_dl_unittests.cc.

                                               {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kYellow());
   paint.setBlendMode(DlBlendMode::kSrc);
   builder.DrawPaint(paint);
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kMultiply);
   builder.SaveLayer(std::nullopt, &save_paint);
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kCornflowerBlue().modulateOpacity(0.75f));
   builder.DrawPaint(draw_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [143/545]

impeller::testing::TEST_P	(	AiksTest	,
		CollapsedDrawPaintInSubpassBackdropFilter
	)

Definition at line 60 of file aiks_dl_unittests.cc.

                                                             {
   // Bug: https://github.com/flutter/flutter/issues/131576
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kYellow());
   paint.setBlendMode(DlBlendMode::kSrc);
   builder.DrawPaint(paint);
  
   auto filter = DlImageFilter::MakeBlur(20.0, 20.0, DlTileMode::kDecal);
   builder.SaveLayer(std::nullopt, nullptr, filter.get());
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kCornflowerBlue());
   builder.DrawPaint(draw_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [144/545]

impeller::testing::TEST_P	(	AiksTest	,
		ColorFilterAdvancedBlend
	)

Definition at line 250 of file aiks_dl_blend_unittests.cc.

                                            {
   bool has_color_filter = true;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::Checkbox("has color filter", &has_color_filter);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     auto src_image =
         DlImageImpeller::Make(CreateTextureForFixture("blend_mode_src.png"));
     auto dst_image =
         DlImageImpeller::Make(CreateTextureForFixture("blend_mode_dst.png"));
  
     std::vector<DlBlendMode> blend_modes = {
         DlBlendMode::kScreen,     DlBlendMode::kOverlay,
         DlBlendMode::kDarken,     DlBlendMode::kLighten,
         DlBlendMode::kColorDodge, DlBlendMode::kColorBurn,
         DlBlendMode::kHardLight,  DlBlendMode::kSoftLight,
         DlBlendMode::kDifference, DlBlendMode::kExclusion,
         DlBlendMode::kMultiply,   DlBlendMode::kHue,
         DlBlendMode::kSaturation, DlBlendMode::kColor,
         DlBlendMode::kLuminosity,
     };
  
     for (uint32_t i = 0; i < blend_modes.size(); ++i) {
       builder.Save();
       builder.Translate((i % 5) * 200, (i / 5) * 200);
       builder.Scale(0.4, 0.4);
       {
         DlPaint dstPaint;
         builder.DrawImage(dst_image, DlPoint(0, 0),
                           DlImageSampling::kMipmapLinear, &dstPaint);
       }
       {
         DlPaint srcPaint;
         srcPaint.setBlendMode(blend_modes[i]);
         if (has_color_filter) {
           std::shared_ptr<const DlColorFilter> color_filter =
               DlColorFilter::MakeBlend(DlColor::RGBA(0.9, 0.5, 0.0, 1.0),
                                        DlBlendMode::kSrcIn);
           srcPaint.setColorFilter(color_filter);
         }
         builder.DrawImage(src_image, DlPoint(0, 0),
                           DlImageSampling::kMipmapLinear, &srcPaint);
       }
       builder.Restore();
     }
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [145/545]

impeller::testing::TEST_P	(	AiksTest	,
		ColorFilterAdvancedBlendNoFbFetch
	)

Definition at line 309 of file aiks_dl_blend_unittests.cc.

                                                     {
   if (GetParam() != PlaygroundBackend::kMetal) {
     GTEST_SKIP()
         << "This backend doesn't yet support setting device capabilities.";
   }
   if (!WillRenderSomething()) {
     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, SupportsFramebufferFetch())
       .Times(::testing::AtLeast(1))
       .WillRepeatedly(::testing::Return(false));
   FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultColorFormat);
   FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultStencilFormat);
   FLT_FORWARD(mock_capabilities, old_capabilities,
               GetDefaultDepthStencilFormat);
   FLT_FORWARD(mock_capabilities, old_capabilities, SupportsOffscreenMSAA);
   FLT_FORWARD(mock_capabilities, old_capabilities,
               SupportsImplicitResolvingMSAA);
   FLT_FORWARD(mock_capabilities, old_capabilities, SupportsReadFromResolve);
   FLT_FORWARD(mock_capabilities, old_capabilities, SupportsSSBO);
   FLT_FORWARD(mock_capabilities, old_capabilities, SupportsCompute);
   FLT_FORWARD(mock_capabilities, old_capabilities,
               SupportsTextureToTextureBlits);
   FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultGlyphAtlasFormat);
   FLT_FORWARD(mock_capabilities, old_capabilities, SupportsTriangleFan);
   FLT_FORWARD(mock_capabilities, old_capabilities,
               SupportsDecalSamplerAddressMode);
   FLT_FORWARD(mock_capabilities, old_capabilities, SupportsPrimitiveRestart);
   FLT_FORWARD(mock_capabilities, old_capabilities, GetMinimumUniformAlignment);
   ASSERT_TRUE(SetCapabilities(mock_capabilities).ok());
  
   bool has_color_filter = true;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::Checkbox("has color filter", &has_color_filter);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     auto src_image =
         DlImageImpeller::Make(CreateTextureForFixture("blend_mode_src.png"));
     auto dst_image =
         DlImageImpeller::Make(CreateTextureForFixture("blend_mode_dst.png"));
  
     std::vector<DlBlendMode> blend_modes = {
         DlBlendMode::kScreen,     DlBlendMode::kOverlay,
         DlBlendMode::kDarken,     DlBlendMode::kLighten,
         DlBlendMode::kColorDodge, DlBlendMode::kColorBurn,
         DlBlendMode::kHardLight,  DlBlendMode::kSoftLight,
         DlBlendMode::kDifference, DlBlendMode::kExclusion,
         DlBlendMode::kMultiply,   DlBlendMode::kHue,
         DlBlendMode::kSaturation, DlBlendMode::kColor,
         DlBlendMode::kLuminosity,
     };
  
     for (uint32_t i = 0; i < blend_modes.size(); ++i) {
       builder.Save();
       builder.Translate((i % 5) * 200, (i / 5) * 200);
       builder.Scale(0.4, 0.4);
       {
         DlPaint dstPaint;
         builder.DrawImage(dst_image, DlPoint(0, 0),
                           DlImageSampling::kMipmapLinear, &dstPaint);
       }
       {
         DlPaint srcPaint;
         srcPaint.setBlendMode(blend_modes[i]);
         if (has_color_filter) {
           std::shared_ptr<const DlColorFilter> color_filter =
               DlColorFilter::MakeBlend(DlColor::RGBA(0.9, 0.5, 0.0, 1.0),
                                        DlBlendMode::kMultiply);
           srcPaint.setColorFilter(color_filter);
         }
         builder.DrawImage(src_image, DlPoint(0, 0),
                           DlImageSampling::kMipmapLinear, &srcPaint);
       }
       builder.Restore();
     }
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::kMetal, impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [146/545]

impeller::testing::TEST_P	(	AiksTest	,
		ColorFilterBlend
	)

Definition at line 198 of file aiks_dl_blend_unittests.cc.

                                    {
   bool has_color_filter = true;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::Checkbox("has color filter", &has_color_filter);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     auto src_image =
         DlImageImpeller::Make(CreateTextureForFixture("blend_mode_src.png"));
     auto dst_image =
         DlImageImpeller::Make(CreateTextureForFixture("blend_mode_dst.png"));
  
     std::vector<DlBlendMode> blend_modes = {
         DlBlendMode::kSrc,     DlBlendMode::kSrcATop, DlBlendMode::kSrcOver,
         DlBlendMode::kSrcIn,   DlBlendMode::kSrcOut,  DlBlendMode::kDst,
         DlBlendMode::kDstATop, DlBlendMode::kDstOver, DlBlendMode::kDstIn,
         DlBlendMode::kDstOut,  DlBlendMode::kClear,   DlBlendMode::kXor};
  
     for (uint32_t i = 0; i < blend_modes.size(); ++i) {
       builder.Save();
       builder.Translate((i % 5) * 200, (i / 5) * 200);
       builder.Scale(0.4, 0.4);
       {
         DlPaint dstPaint;
         builder.DrawImage(dst_image, DlPoint(0, 0),
                           DlImageSampling::kMipmapLinear, &dstPaint);
       }
       {
         DlPaint srcPaint;
         srcPaint.setBlendMode(blend_modes[i]);
         if (has_color_filter) {
           std::shared_ptr<const DlColorFilter> color_filter =
               DlColorFilter::MakeBlend(DlColor::RGBA(0.9, 0.5, 0.0, 1.0),
                                        DlBlendMode::kSrcIn);
           srcPaint.setColorFilter(color_filter);
         }
         builder.DrawImage(src_image, DlPoint(0, 0),
                           DlImageSampling::kMipmapLinear, &srcPaint);
       }
       builder.Restore();
     }
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [147/545]

impeller::testing::TEST_P	(	AiksTest	,
		ColorMatrixFilterSubpassCollapseOptimization
	)

Definition at line 79 of file aiks_dl_unittests.cc.

                                                                {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
   builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
  
   const float matrix[20] = {
       -1.0, 0,    0,    1.0, 0,  //
       0,    -1.0, 0,    1.0, 0,  //
       0,    0,    -1.0, 1.0, 0,  //
       1.0,  1.0,  1.0,  1.0, 0   //
   };
   auto filter = DlColorFilter::MakeMatrix(matrix);
  
   DlPaint paint;
   paint.setColorFilter(filter);
   builder.SaveLayer(std::nullopt, &paint);
  
   builder.Translate(500, 300);
   builder.Rotate(120);  // 120 deg
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), draw_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [148/545]

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 773 of file aiks_dl_blend_unittests.cc.

                              {
   // Compare with https://fiddle.skia.org/c/@BlendModes
  
   BlendModeSelection blend_modes = GetBlendModeSelection();
  
   auto draw_color_wheel = [](DisplayListBuilder& builder) -> void {
     /// color_wheel_sampler: r=0 -> fuchsia, r=2pi/3 -> yellow, r=4pi/3 ->
     /// cyan domain: r >= 0 (because modulo used is non euclidean)
     auto color_wheel_sampler = [](Radians r) {
       Scalar x = r.radians / k2Pi + 1;
  
       // https://www.desmos.com/calculator/6nhjelyoaj
       auto color_cycle = [](Scalar x) {
         Scalar cycle = std::fmod(x, 6.0f);
         return std::max(0.0f, std::min(1.0f, 2 - std::abs(2 - cycle)));
       };
       return Color(color_cycle(6 * x + 1),  //
                    color_cycle(6 * x - 1),  //
                    color_cycle(6 * x - 3),  //
                    1);
     };
  
     DlPaint paint;
     paint.setBlendMode(DlBlendMode::kSrcOver);
  
     // Draw a fancy color wheel for the backdrop.
     // https://www.desmos.com/calculator/xw7kafthwd
     const int max_dist = 900;
     for (int i = 0; i <= 900; i++) {
       Radians r(kPhi / k2Pi * i);
       Scalar distance = r.radians / std::powf(4.12, 0.0026 * r.radians);
       Scalar normalized_distance = static_cast<Scalar>(i) / max_dist;
  
       auto color = color_wheel_sampler(r).WithAlpha(1.0f - normalized_distance);
       paint.setColor(
           DlColor::RGBA(color.red, color.green, color.blue, color.alpha));
       DlPoint position = DlPoint(distance * std::sin(r.radians),
                                  -distance * std::cos(r.radians));
  
       builder.DrawCircle(position, 9 + normalized_distance * 3, paint);
     }
   };
  
   auto callback = [&]() -> sk_sp<DisplayList> {
     // UI state.
     static bool cache_the_wheel = true;
     static int current_blend_index = 3;
     static float dst_alpha = 1;
     static float src_alpha = 1;
     static DlColor color0 = DlColor::kRed();
     static DlColor color1 = DlColor::kGreen();
     static DlColor color2 = DlColor::kBlue();
  
     if (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();
     }
  
     DisplayListBuilder builder;
  
     DlPaint paint;
     paint.setColor(DlColor::kWhite().withAlpha(dst_alpha * 255));
     paint.setBlendMode(DlBlendMode::kSrc);
     builder.SaveLayer(std::nullopt, &paint);
     {
       DlPaint paint;
       paint.setColor(DlColor::kWhite());
       builder.DrawPaint(paint);
  
       builder.SaveLayer(std::nullopt, nullptr);
       builder.Scale(GetContentScale().x, GetContentScale().y);
       builder.Translate(500, 400);
       builder.Scale(3, 3);
       draw_color_wheel(builder);
       builder.Restore();
     }
     builder.Restore();
  
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.Translate(500, 400);
     builder.Scale(3, 3);
  
     // Draw 3 circles to a subpass and blend it in.
     DlPaint save_paint;
     save_paint.setColor(DlColor::kWhite().withAlpha(src_alpha * 255));
     save_paint.setBlendMode(static_cast<DlBlendMode>(
         blend_modes.blend_mode_values[current_blend_index]));
     builder.SaveLayer(std::nullopt, &save_paint);
     {
       DlPaint paint;
       paint.setBlendMode(DlBlendMode::kPlus);
       const Scalar x = std::sin(k2Pi / 3);
       const Scalar y = -std::cos(k2Pi / 3);
       paint.setColor(color0);
       builder.DrawCircle(DlPoint(-x * 45, y * 45), 65, paint);
       paint.setColor(color1);
       builder.DrawCircle(DlPoint(0, -45), 65, paint);
       paint.setColor(color2);
       builder.DrawCircle(DlPoint(x * 45, y * 45), 65, paint);
     }
     builder.Restore();
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::testing::BlendModeSelection::blend_mode_names, impeller::testing::BlendModeSelection::blend_mode_values, impeller::saturated::distance, GetBlendModeSelection(), impeller::AiksPlayground::ImGuiBegin(), impeller::k2Pi, impeller::kPhi, impeller::Radians::radians, and x.

◆ TEST_P() [149/545]

impeller::testing::TEST_P	(	AiksTest	,
		CoordinateConversionsAreCorrect
	)

Definition at line 1612 of file aiks_dl_basic_unittests.cc.

                                                   {
   DisplayListBuilder builder;
  
   // Render a texture directly.
   {
     auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
     builder.Save();
     builder.Translate(100, 200);
     builder.Scale(0.5, 0.5);
     builder.DrawImage(image, DlPoint(100.0, 100.0),
                       DlImageSampling::kNearestNeighbor);
     builder.Restore();
   }
  
   // Render an offscreen rendered texture.
   {
     DlPaint alpha;
     alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
  
     builder.SaveLayer(std::nullopt, &alpha);
  
     DlPaint paint;
     paint.setColor(DlColor::kRed());
     builder.DrawRect(DlRect::MakeXYWH(000, 000, 100, 100), paint);
     paint.setColor(DlColor::kGreen());
     builder.DrawRect(DlRect::MakeXYWH(020, 020, 100, 100), paint);
     paint.setColor(DlColor::kBlue());
     builder.DrawRect(DlRect::MakeXYWH(040, 040, 100, 100), paint);
  
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [150/545]

impeller::testing::TEST_P	(	AiksTest	,
		CoverageOriginShouldBeAccountedForInSubpasses
	)

Definition at line 1793 of file aiks_dl_basic_unittests.cc.

                                                                 {
   auto callback = [&]() -> sk_sp<DisplayList> {
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     DlPaint alpha;
     alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
  
     auto current = Point{25, 25};
     const auto offset = Point{25, 25};
     const auto size = Size(100, 100);
  
     static PlaygroundPoint point_a(Point(40, 40), 10, Color::White());
     static PlaygroundPoint point_b(Point(160, 160), 10, Color::White());
     auto [b0, b1] = DrawPlaygroundLine(point_a, point_b);
     DlRect bounds = DlRect::MakeLTRB(b0.x, b0.y, b1.x, b1.y);
  
     DlPaint stroke_paint;
     stroke_paint.setColor(DlColor::kYellow());
     stroke_paint.setStrokeWidth(5);
     stroke_paint.setDrawStyle(DlDrawStyle::kStroke);
     builder.DrawRect(bounds, stroke_paint);
  
     builder.SaveLayer(bounds, &alpha);
  
     DlPaint paint;
     paint.setColor(DlColor::kRed());
     builder.DrawRect(
         DlRect::MakeXYWH(current.x, current.y, size.width, size.height), paint);
  
     paint.setColor(DlColor::kGreen());
     current += offset;
     builder.DrawRect(
         DlRect::MakeXYWH(current.x, current.y, size.width, size.height), paint);
  
     paint.setColor(DlColor::kBlue());
     current += offset;
     builder.DrawRect(
         DlRect::MakeXYWH(current.x, current.y, size.width, size.height), paint);
  
     builder.Restore();
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundLine(), and impeller::Color::White().

◆ TEST_P() [151/545]

impeller::testing::TEST_P	(	AiksTest	,
		DepthValuesForLineMode
	)

Definition at line 984 of file aiks_dl_unittests.cc.

                                          {
   // Ensures that the additional draws created by line/polygon mode all
   // have the same depth values.
   DisplayListBuilder builder;
  
   DlPath path = DlPath::MakeCircle(DlPoint(100, 100), 100);
  
   builder.DrawPath(path, DlPaint()
                              .setColor(DlColor::kRed())
                              .setDrawStyle(DlDrawStyle::kStroke)
                              .setStrokeWidth(5));
   builder.Save();
   builder.ClipPath(path);
  
   std::vector<DlPoint> points = {
       DlPoint::MakeXY(0, -200), DlPoint::MakeXY(400, 200),
       DlPoint::MakeXY(0, -100), DlPoint::MakeXY(400, 300),
       DlPoint::MakeXY(0, 0),    DlPoint::MakeXY(400, 400),
       DlPoint::MakeXY(0, 100),  DlPoint::MakeXY(400, 500),
       DlPoint::MakeXY(0, 150),  DlPoint::MakeXY(400, 600)};
  
   builder.DrawPoints(DlPointMode::kLines, points.size(), points.data(),
                      DlPaint().setColor(DlColor::kBlue()).setStrokeWidth(10));
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References points.

◆ TEST_P() [152/545]

impeller::testing::TEST_P	(	AiksTest	,
		DepthValuesForPolygonMode
	)

Definition at line 1012 of file aiks_dl_unittests.cc.

                                             {
   // Ensures that the additional draws created by line/polygon mode all
   // have the same depth values.
   DisplayListBuilder builder;
  
   DlPath path = DlPath::MakeCircle(DlPoint(100, 100), 100);
  
   builder.DrawPath(path, DlPaint()
                              .setColor(DlColor::kRed())
                              .setDrawStyle(DlDrawStyle::kStroke)
                              .setStrokeWidth(5));
   builder.Save();
   builder.ClipPath(path);
  
   std::vector<DlPoint> points = {
       DlPoint::MakeXY(0, -200), DlPoint::MakeXY(400, 200),
       DlPoint::MakeXY(0, -100), DlPoint::MakeXY(400, 300),
       DlPoint::MakeXY(0, 0),    DlPoint::MakeXY(400, 400),
       DlPoint::MakeXY(0, 100),  DlPoint::MakeXY(400, 500),
       DlPoint::MakeXY(0, 150),  DlPoint::MakeXY(400, 600)};
  
   builder.DrawPoints(DlPointMode::kPolygon, points.size(), points.data(),
                      DlPaint().setColor(DlColor::kBlue()).setStrokeWidth(10));
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References points.

◆ TEST_P() [153/545]

impeller::testing::TEST_P	(	AiksTest	,
		DestructiveBlendColorFilterFloodsClip
	)

Definition at line 890 of file aiks_dl_blend_unittests.cc.

                                                         {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawPaint(paint);
  
   DlPaint save_paint;
   save_paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kSrc));
   builder.SaveLayer(std::nullopt, &save_paint);
   builder.Restore();
  
   // Should be solid red as the destructive color filter floods the clip.
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [154/545]

impeller::testing::TEST_P	(	AiksTest	,
		DifferenceClipsMustRenderIdenticallyAcrossBackends
	)

Definition at line 631 of file aiks_dl_text_unittests.cc.

                                                                      {
   DisplayListBuilder builder;
  
   DlPaint paint;
   DlColor clear_color(1.0, 0.5, 0.5, 0.5, DlColorSpace::kSRGB);
   paint.setColor(clear_color);
   builder.DrawPaint(paint);
  
   DlMatrix identity = {
       1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
       0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
   };
   builder.Save();
   builder.Transform(identity);
  
   DlRect frame = DlRect::MakeLTRB(1.0, 1.0, 1278.0, 763.0);
   DlColor white(1.0, 1.0, 1.0, 1.0, DlColorSpace::kSRGB);
   paint.setColor(white);
   builder.DrawRect(frame, paint);
  
   builder.Save();
   builder.ClipRect(frame, DlClipOp::kIntersect);
  
   DlMatrix rect_xform = {
       0.8241262, 0.56640625, 0.0, 0.0, -0.56640625, 0.8241262, 0.0, 0.0,
       0.0,       0.0,        1.0, 0.0, 271.1137,    489.4733,  0.0, 1.0,
   };
   builder.Save();
   builder.Transform(rect_xform);
  
   DlRect rect = DlRect::MakeLTRB(0.0, 0.0, 100.0, 100.0);
   DlColor bluish(1.0, 0.184, 0.501, 0.929, DlColorSpace::kSRGB);
   paint.setColor(bluish);
   DlRoundRect rrect = DlRoundRect::MakeRectRadius(rect, 18.0);
   builder.DrawRoundRect(rrect, paint);
  
   builder.Save();
   builder.ClipRect(rect, DlClipOp::kIntersect);
   builder.Restore();
  
   builder.Restore();
  
   DlMatrix path_xform = {
       1.0, 0.0, 0.0, 0.0, 0.0,   1.0,   0.0, 0.0,
       0.0, 0.0, 1.0, 0.0, 675.0, 279.5, 0.0, 1.0,
   };
   builder.Save();
   builder.Transform(path_xform);
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(87.5, 349.5));
   path_builder.LineTo(DlPoint(25.0, 29.5));
   path_builder.LineTo(DlPoint(150.0, 118.0));
   path_builder.LineTo(DlPoint(25.0, 118.0));
   path_builder.LineTo(DlPoint(150.0, 29.5));
   path_builder.Close();
   DlPath path = path_builder.TakePath();
  
   DlColor fill_color(1.0, 1.0, 0.0, 0.0, DlColorSpace::kSRGB);
   DlColor stroke_color(1.0, 0.0, 0.0, 0.0, DlColorSpace::kSRGB);
   paint.setColor(fill_color);
   paint.setDrawStyle(DlDrawStyle::kFill);
   builder.DrawPath(path, paint);
  
   paint.setColor(stroke_color);
   paint.setStrokeWidth(2.0);
   paint.setDrawStyle(DlDrawStyle::kStroke);
   builder.DrawPath(path, paint);
  
   builder.Restore();
   builder.Restore();
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [155/545]

impeller::testing::TEST_P	(	AiksTest	,
		DispatcherDoesNotCullPerspectiveTransformedChildDisplayLists
	)

Definition at line 871 of file aiks_dl_unittests.cc.

                                                                                {
   flutter::DisplayListBuilder sub_builder(true);
   sub_builder.DrawRect(DlRect::MakeXYWH(0, 0, 50, 50),
                        flutter::DlPaint(flutter::DlColor::kRed()));
   auto display_list = sub_builder.Build();
  
   AiksContext context(GetContext(), nullptr);
   RenderTarget render_target =
       context.GetContentContext().GetRenderTargetCache()->CreateOffscreen(
           *context.GetContext(), {2400, 1800}, 1);
  
   DisplayListBuilder builder;
  
   builder.Scale(2.0, 2.0);
   builder.Translate(-93.0, 0.0);
  
   // clang-format off
   builder.TransformFullPerspective(
      0.8, -0.2, -0.1, -0.0,
      0.0,  1.0,  0.0,  0.0,
      1.4,  1.3,  1.0,  0.0,
     63.2, 65.3, 48.6,  1.1
   );
   // clang-format on
   builder.Translate(35.0, 75.0);
   builder.DrawDisplayList(display_list, 1.0f);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::AiksContext::GetContentContext(), impeller::AiksContext::GetContext(), and impeller::ContentContext::GetRenderTargetCache().

◆ TEST_P() [156/545]

impeller::testing::TEST_P	(	AiksTest	,
		DisplayListToTextureAllocationFailure
	)

Definition at line 1112 of file aiks_dl_unittests.cc.

                                                         {
   ScopedValidationDisable disable_validations;
   DisplayListBuilder builder;
  
   AiksContext aiks_context(GetContext(), nullptr);
   // Use intentionally invalid dimensions that would trigger an allocation
   // failure.
   auto texture =
       DisplayListToTexture(builder.Build(), ISize{0, 0}, aiks_context);
  
   EXPECT_EQ(texture, nullptr);
 }

References impeller::DisplayListToTexture().

◆ TEST_P() [157/545]

impeller::testing::TEST_P	(	AiksTest	,
		DisplayListToTextureWithMipGeneration
	)

Definition at line 1125 of file aiks_dl_unittests.cc.

                                                         {
   DisplayListBuilder builder;
  
   std::shared_ptr<DlImageFilter> filter =
       DlImageFilter::MakeBlur(8, 8, DlTileMode::kClamp);
   builder.SaveLayer(std::nullopt, nullptr, filter.get());
   builder.Restore();
  
   AiksContext aiks_context(GetContext(), nullptr);
   // Use intentionally invalid dimensions that would trigger an allocation
   // failure.
   auto texture =
       DisplayListToTexture(builder.Build(), ISize{10, 10}, aiks_context,
                            /*reset_host_buffer=*/true, /*generate_mips=*/true);
  
   EXPECT_FALSE(texture->NeedsMipmapGeneration());
 }

References impeller::DisplayListToTexture().

◆ TEST_P() [158/545]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometryBlend
	)

Definition at line 201 of file aiks_dl_atlas_unittests.cc.

                                        {
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   std::vector<DlColor> colors;
   colors.reserve(texture_coordinates.size());
   for (auto i = 0u; i < texture_coordinates.size(); i++) {
     colors.push_back(DlColor::ARGB(0.5, 1, 1, 1));
   }
   DlAtlasGeometry geom(
       atlas->impeller_texture(), transforms.data(), texture_coordinates.data(),
       colors.data(), transforms.size(), BlendMode::kSrcOver, {}, std::nullopt);
  
   EXPECT_TRUE(geom.ShouldUseBlend());
   EXPECT_FALSE(geom.ShouldSkip());
  
   ContentContext context(GetContext(), nullptr);
   auto vertex_buffer =
       geom.CreateBlendVertexBuffer(context.GetTransientsBuffer());
  
   EXPECT_EQ(vertex_buffer.index_type, IndexType::kNone);
   EXPECT_EQ(vertex_buffer.vertex_count, texture_coordinates.size() * 6);
 }

References impeller::DlAtlasGeometry::CreateBlendVertexBuffer(), impeller::ContentContext::GetTransientsBuffer(), impeller::kNone, impeller::kSrcOver, impeller::DlAtlasGeometry::ShouldSkip(), and impeller::DlAtlasGeometry::ShouldUseBlend().

◆ TEST_P() [159/545]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometryColorButNoBlend
	)

Definition at line 224 of file aiks_dl_atlas_unittests.cc.

                                                  {
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   std::vector<DlColor> colors;
   colors.reserve(texture_coordinates.size());
   for (auto i = 0u; i < texture_coordinates.size(); i++) {
     colors.push_back(DlColor::ARGB(0.5, 1, 1, 1));
   }
   DlAtlasGeometry geom(atlas->impeller_texture(), transforms.data(),
                        texture_coordinates.data(), colors.data(),
                        transforms.size(), BlendMode::kSrc, {}, std::nullopt);
  
   // Src blend mode means that colors would be ignored, even if provided.
   EXPECT_FALSE(geom.ShouldUseBlend());
   EXPECT_FALSE(geom.ShouldSkip());
 }

References impeller::kSrc, impeller::DlAtlasGeometry::ShouldSkip(), and impeller::DlAtlasGeometry::ShouldUseBlend().

◆ TEST_P() [160/545]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometryNoBlendRenamed
	)

Definition at line 183 of file aiks_dl_atlas_unittests.cc.

                                                 {
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   DlAtlasGeometry geom(atlas->impeller_texture(), transforms.data(),
                        texture_coordinates.data(), nullptr, transforms.size(),
                        BlendMode::kSrcOver, {}, std::nullopt);
  
   EXPECT_FALSE(geom.ShouldUseBlend());
   EXPECT_FALSE(geom.ShouldSkip());
  
   ContentContext context(GetContext(), nullptr);
   auto vertex_buffer =
       geom.CreateSimpleVertexBuffer(context.GetTransientsBuffer());
  
   EXPECT_EQ(vertex_buffer.index_type, IndexType::kNone);
   EXPECT_EQ(vertex_buffer.vertex_count, texture_coordinates.size() * 6);
 }

References impeller::DlAtlasGeometry::CreateSimpleVertexBuffer(), impeller::ContentContext::GetTransientsBuffer(), impeller::kNone, impeller::kSrcOver, impeller::DlAtlasGeometry::ShouldSkip(), and impeller::DlAtlasGeometry::ShouldUseBlend().

◆ TEST_P() [161/545]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometrySkip
	)

Definition at line 241 of file aiks_dl_atlas_unittests.cc.

                                       {
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   std::vector<DlColor> colors;
   colors.reserve(texture_coordinates.size());
   for (auto i = 0u; i < texture_coordinates.size(); i++) {
     colors.push_back(DlColor::ARGB(0.5, 1, 1, 1));
   }
   DlAtlasGeometry geom(atlas->impeller_texture(), transforms.data(),
                        texture_coordinates.data(), colors.data(),
                        transforms.size(), BlendMode::kClear, {}, std::nullopt);
   EXPECT_TRUE(geom.ShouldSkip());
 }

References impeller::kClear, and impeller::DlAtlasGeometry::ShouldSkip().

◆ TEST_P() [162/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAdvancedBlendPartlyOffscreen
	)

Definition at line 142 of file aiks_dl_blend_unittests.cc.

                                                    {
   DisplayListBuilder builder;
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawPaint(draw_paint);
   builder.Scale(2, 2);
   builder.ClipRect(DlRect::MakeLTRB(0, 0, 200, 200));
  
   std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                  DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0)};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   DlPaint paint;
   DlMatrix matrix = DlMatrix::MakeScale({0.3, 0.3, 1.0});
   paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/{0, 0},             //
       /*end_point=*/{100, 100},           //
       /*stop_count=*/colors.size(),       //
       /*colors=*/colors.data(),           //
       /*stops=*/stops.data(),             //
       /*tile_mode=*/DlTileMode::kRepeat,  //
       /*matrix=*/&matrix                  //
       ));
   paint.setBlendMode(DlBlendMode::kLighten);
  
   builder.DrawCircle(DlPoint(100, 100), 100, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [163/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasAdvancedAndTransform
	)

Definition at line 137 of file aiks_dl_atlas_unittests.cc.

                                                 {
   DisplayListBuilder builder;
   // Draws the image as four squares stiched together.
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   builder.Scale(0.25, 0.25);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     /*colors=*/nullptr, /*count=*/4, DlBlendMode::kModulate,
                     DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [164/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasNoColor
	)

Definition at line 60 of file aiks_dl_atlas_unittests.cc.

                                    {
   DisplayListBuilder builder;
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     /*colors=*/nullptr, /*count=*/4, DlBlendMode::kSrcOver,
                     DlImageSampling::kNearestNeighbor, nullptr);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [165/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasNoColorFullSize
	)

Definition at line 120 of file aiks_dl_atlas_unittests.cc.

                                            {
   auto atlas = DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
   auto size = atlas->impeller_texture()->GetSize();
   std::vector<DlRect> texture_coordinates = {
       DlRect::MakeLTRB(0, 0, size.width, size.height)};
   std::vector<RSTransform> transforms = {MakeTranslation(0, 0)};
  
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     /*colors=*/nullptr, /*count=*/1, DlBlendMode::kSrcOver,
                     DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [166/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasPlusWideGamut
	)

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

References impeller::kB10G10R10A10XR.

◆ TEST_P() [167/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorAdvanced
	)

Definition at line 72 of file aiks_dl_atlas_unittests.cc.

                                              {
   DisplayListBuilder builder;
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                  DlColor::kBlue(), DlColor::kYellow()};
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     colors.data(), /*count=*/4, DlBlendMode::kModulate,
                     DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [168/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorAdvancedAndTransform
	)

Definition at line 151 of file aiks_dl_atlas_unittests.cc.

                                                          {
   DisplayListBuilder builder;
   // Draws the image as four squares stiched together.
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                  DlColor::kBlue(), DlColor::kYellow()};
  
   builder.Scale(0.25, 0.25);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     colors.data(), /*count=*/4, DlBlendMode::kModulate,
                     DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [169/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorSimple
	)

Definition at line 87 of file aiks_dl_atlas_unittests.cc.

                                            {
   DisplayListBuilder builder;
   // Draws the image as four squares stiched together.
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                  DlColor::kBlue(), DlColor::kYellow()};
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     colors.data(), /*count=*/4, DlBlendMode::kSrcATop,
                     DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [170/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithOpacity
	)

Definition at line 103 of file aiks_dl_atlas_unittests.cc.

                                        {
   DisplayListBuilder builder;
   // Draws the image as four squares stiched together slightly
   // opaque
   auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  
   DlPaint paint;
   paint.setAlpha(128);
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                     /*colors=*/nullptr, 4, DlBlendMode::kSrcOver,
                     DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr,
                     &paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [171/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawImageRectSrcOutsideBounds
	)

Definition at line 229 of file aiks_dl_basic_unittests.cc.

                                                 {
   DisplayListBuilder builder;
   auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  
   // Use a source rect that is partially outside the bounds of the image.
   auto source_rect = DlRect::MakeXYWH(
       image->GetSize().width * 0.25f, image->GetSize().height * 0.4f,
       image->GetSize().width, image->GetSize().height);
  
   auto dest_rect = DlRect::MakeXYWH(100, 100, 600, 600);
  
   DlPaint paint;
   paint.setColor(DlColor::kMidGrey());
   builder.DrawRect(dest_rect, paint);
  
   builder.DrawImageRect(image, source_rect, dest_rect,
                         DlImageSampling::kNearestNeighbor);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [172/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawImageRectWithBlendColorFilter
	)

Definition at line 255 of file aiks_dl_atlas_unittests.cc.

                                                     {
   sk_sp<DlImageImpeller> texture =
       DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
  
   DisplayListBuilder builder;
   DlPaint paint = DlPaint().setColorFilter(DlColorFilter::MakeBlend(
       DlColor::kRed().withAlphaF(0.4), DlBlendMode::kSrcOver));
  
   DlMatrix filter_matrix = DlMatrix();
   auto filter = flutter::DlMatrixImageFilter(filter_matrix,
                                              flutter::DlImageSampling::kLinear);
   DlPaint paint_with_filter = paint;
   paint_with_filter.setImageFilter(&filter);
  
   // Compare porter-duff blend modes.
   builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
   // Uses image filter to disable atlas conversion.
   builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                         DlRect::MakeLTRB(0, 0, 500, 500), {},
                         &paint_with_filter);
  
   // Uses atlas conversion.
   builder.Translate(600, 0);
   builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                         DlRect::MakeLTRB(0, 0, 500, 500), {}, &paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [173/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawImageRectWithMatrixColorFilter
	)

Definition at line 284 of file aiks_dl_atlas_unittests.cc.

                                                      {
   sk_sp<DlImageImpeller> texture =
       DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
  
   DisplayListBuilder builder;
   static const constexpr ColorMatrix kColorInversion = {
       .array = {
           -1.0, 0,    0,    1.0, 0,  //
           0,    -1.0, 0,    1.0, 0,  //
           0,    0,    -1.0, 1.0, 0,  //
           1.0,  1.0,  1.0,  1.0, 0   //
       }};
   DlPaint paint = DlPaint().setColorFilter(
       DlColorFilter::MakeMatrix(kColorInversion.array));
  
   DlMatrix filter_matrix = DlMatrix();
   auto filter = flutter::DlMatrixImageFilter(filter_matrix,
                                              flutter::DlImageSampling::kLinear);
   DlPaint paint_with_filter = paint;
   paint_with_filter.setImageFilter(&filter);
  
   // Compare inverting color matrix filter.
   builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
   // Uses image filter to disable atlas conversion.
   builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                         DlRect::MakeLTRB(0, 0, 500, 500), {},
                         &paint_with_filter);
  
   // Uses atlas conversion.
   builder.Translate(600, 0);
   builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                         DlRect::MakeLTRB(0, 0, 500, 500), {}, &paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::ColorMatrix::array, impeller::kColorInversion, and impeller::DlImageImpeller::Make().

◆ TEST_P() [174/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesRenderCorrectly
	)

Definition at line 553 of file aiks_dl_path_unittests.cc.

                                            {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   paint.setStrokeWidth(10);
  
   auto draw = [&builder](DlPaint& paint) {
     for (auto cap :
          {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
       paint.setStrokeCap(cap);
       DlPoint origin = {100, 100};
       builder.DrawLine(DlPoint(150, 100), DlPoint(250, 100), paint);
       for (int d = 15; d < 90; d += 15) {
         Matrix m = Matrix::MakeRotationZ(Degrees(d));
         Point origin = {100, 100};
         Point p0 = {50, 0};
         Point p1 = {150, 0};
         auto a = origin + m * p0;
         auto b = origin + m * p1;
  
         builder.DrawLine(a, b, paint);
       }
       builder.DrawLine(DlPoint(100, 150), DlPoint(100, 250), paint);
       builder.DrawCircle(origin, 35, paint);
  
       builder.DrawLine(DlPoint(250, 250), DlPoint(250, 250), paint);
  
       builder.Translate(250, 0);
     }
     builder.Translate(-750, 250);
   };
  
   std::vector<DlColor> colors = {
       DlColor::ARGB(1, 0x1f / 255.0, 0.0, 0x5c / 255.0),
       DlColor::ARGB(1, 0x5b / 255.0, 0.0, 0x60 / 255.0),
       DlColor::ARGB(1, 0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0),
       DlColor::ARGB(1, 0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0),
       DlColor::ARGB(1, 0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0),
       DlColor::ARGB(1, 0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0),
       DlColor::ARGB(1, 0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0)};
   std::vector<Scalar> stops = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
  
   auto texture = DlImageImpeller::Make(
       CreateTextureForFixture("airplane.jpg",
                               /*enable_mipmapping=*/true));
  
   draw(paint);
  
   paint.setColorSource(DlColorSource::MakeRadial({100, 100}, 200, stops.size(),
                                                  colors.data(), stops.data(),
                                                  DlTileMode::kMirror));
   draw(paint);
  
   DlMatrix matrix = DlMatrix::MakeTranslation({-150, 75});
   paint.setColorSource(DlColorSource::MakeImage(
       texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kMipmapLinear, &matrix));
   draw(paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::saturated::b, impeller::DlImageImpeller::Make(), impeller::Matrix::MakeRotationZ(), and x.

◆ TEST_P() [175/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawOpacityPeephole
	)

Definition at line 18 of file aiks_dl_opacity_unittests.cc.

                                       {
   DisplayListBuilder builder;
  
   DlPaint green;
   green.setColor(DlColor::kGreen().modulateOpacity(0.5));
  
   DlPaint alpha;
   alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
  
   builder.SaveLayer(std::nullopt, &alpha);
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), green);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [176/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintTransformsBounds
	)

Definition at line 63 of file aiks_dl_runtime_effect_unittests.cc.

                                             {
   struct FragUniforms {
     Size size;
   } frag_uniforms = {.size = Size::MakeWH(400, 400)};
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(FragUniforms));
   memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
  
   DlPaint paint;
   paint.setColorSource(
       MakeRuntimeEffect(this, "gradient.frag.iplr", uniform_data));
  
   DisplayListBuilder builder;
   builder.Save();
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawPaint(paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::TSize< Scalar >::MakeWH(), and x.

◆ TEST_P() [177/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintWithAdvancedBlendOverFilter
	)

Definition at line 125 of file aiks_dl_blend_unittests.cc.

                                                        {
   DlPaint paint;
   paint.setColor(DlColor::kBlack());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 60));
  
   DisplayListBuilder builder;
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
   paint.setColor(DlColor::kBlack());
   builder.DrawCircle(DlPoint(300, 300), 200, paint);
   paint.setColor(DlColor::kGreen());
   paint.setBlendMode(DlBlendMode::kScreen);
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [178/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectStrokesRenderCorrectly
	)

Definition at line 784 of file aiks_dl_path_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(10);
  
   builder.Translate(100, 100);
   builder.DrawPath(DlPath::MakeRect(DlRect::MakeSize(DlSize(100, 100))), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [179/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectStrokesWithBevelJoinRenderCorrectly
	)

Definition at line 797 of file aiks_dl_path_unittests.cc.

                                                               {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(10);
   paint.setStrokeJoin(DlStrokeJoin::kBevel);
  
   builder.Translate(100, 100);
   builder.DrawPath(DlPath::MakeRect(DlRect::MakeSize(DlSize(100, 100))), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [180/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawScaledTextWithPerspectiveNoSaveLayer
	)

Definition at line 507 of file aiks_dl_text_unittests.cc.

                                                            {
   DisplayListBuilder builder;
  
   Matrix matrix = Matrix(1.0, 0.0, 0.0, 0.0,    //
                          0.0, 1.0, 0.0, 0.0,    //
                          0.0, 0.0, 1.0, 0.01,   //
                          0.0, 0.0, 0.0, 1.0) *  //
                   Matrix::MakeRotationY({Degrees{10}});
  
   builder.Transform(matrix);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "Hello world",
                                      "Roboto-Regular.ttf"));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia(), and impeller::Matrix::Transform().

◆ TEST_P() [181/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawScaledTextWithPerspectiveSaveLayer
	)

Definition at line 523 of file aiks_dl_text_unittests.cc.

                                                          {
   DisplayListBuilder builder;
  
   Matrix matrix = Matrix(1.0, 0.0, 0.0, 0.0,    //
                          0.0, 1.0, 0.0, 0.0,    //
                          0.0, 0.0, 1.0, 0.01,   //
                          0.0, 0.0, 0.0, 1.0) *  //
                   Matrix::MakeRotationY({Degrees{10}});
  
   DlPaint save_paint;
   DlRect window_bounds =
       DlRect::MakeXYWH(0, 0, GetWindowSize().width, GetWindowSize().height);
   // Note: bounds were not needed by the AIKS version, which may indicate a bug.
   builder.SaveLayer(window_bounds, &save_paint);
   builder.Transform(matrix);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "Hello world",
                                      "Roboto-Regular.ttf"));
  
   builder.Restore();
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia().

◆ TEST_P() [182/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesImageSourceWithTextureCoordinates
	)

Definition at line 271 of file aiks_dl_vertices_unittests.cc.

                                                                 {
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   auto dl_image = DlImageImpeller::Make(texture);
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
   };
   std::vector<DlPoint> texture_coordinates = {
       DlPoint(0, 0),
       DlPoint(100, 200),
       DlPoint(200, 100),
   };
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, 3, positions.data(),
       texture_coordinates.data(), /*colors=*/nullptr);
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   auto image_source = flutter::DlColorSource::MakeImage(
       dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
  
   paint.setColorSource(image_source);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [183/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesImageSourceWithTextureCoordinatesAndColorBlending
	)

Definition at line 301 of file aiks_dl_vertices_unittests.cc.

                                                                       {
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   auto dl_image = DlImageImpeller::Make(texture);
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
   };
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kWhite(),
                                           flutter::DlColor::kGreen(),
                                           flutter::DlColor::kWhite()};
   std::vector<DlPoint> texture_coordinates = {
       DlPoint(0, 0),
       DlPoint(100, 200),
       DlPoint(200, 100),
   };
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, 3, positions.data(),
       texture_coordinates.data(), colors.data());
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   auto image_source = flutter::DlColorSource::MakeImage(
       dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
  
   paint.setColorSource(image_source);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kModulate, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [184/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithEmptySize
	)

Definition at line 284 of file canvas_unittests.cc.

                                                           {
   RenderCallback callback = [&](RenderTarget& render_target) {
     ContentContext context(GetContext(), nullptr);
     Canvas canvas(context, render_target, true, false);
  
     std::vector<flutter::DlPoint> vertex_coordinates = {
         flutter::DlPoint(0, 0),
         flutter::DlPoint(600, 0),
         flutter::DlPoint(0, 600),
     };
     std::vector<flutter::DlPoint> texture_coordinates = {
         flutter::DlPoint(0, 0),
         flutter::DlPoint(500, 0),
         flutter::DlPoint(0, 500),
     };
     std::vector<uint16_t> indices = {0, 1, 2};
     flutter::DlVertices::Builder vertices_builder(
         flutter::DlVertexMode::kTriangleStrip, vertex_coordinates.size(),
         flutter::DlVertices::Builder::kHasTextureCoordinates, indices.size());
     vertices_builder.store_vertices(vertex_coordinates.data());
     vertices_builder.store_indices(indices.data());
     vertices_builder.store_texture_coordinates(texture_coordinates.data());
     auto vertices = vertices_builder.build();
  
     // The start and end points of the gradient form an empty rectangle.
     std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                             flutter::DlColor::kRed()};
     std::vector<Scalar> stops = {0.0, 1.0};
     auto gradient = flutter::DlColorSource::MakeLinear(
         {0, 0}, {0, 600}, 2, colors.data(), stops.data(),
         flutter::DlTileMode::kClamp);
  
     Paint paint;
     paint.color_source = gradient.get();
     canvas.DrawVertices(std::make_shared<DlVerticesGeometry>(vertices, context),
                         BlendMode::kSrcOver, paint);
  
     canvas.EndReplay();
     return true;
   };
  
   ASSERT_TRUE(Playground::OpenPlaygroundHere(callback));
 }

References impeller::Paint::color_source, impeller::Canvas::DrawVertices(), impeller::Canvas::EndReplay(), impeller::kSrcOver, and impeller::Playground::OpenPlaygroundHere().

◆ TEST_P() [185/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithoutIndices
	)

Definition at line 210 of file aiks_dl_vertices_unittests.cc.

                                                            {
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
   };
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, 3, positions.data(),
       /*texture_coordinates=*/nullptr, /*colors=*/nullptr);
  
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kRed()};
   const float stops[2] = {0.0, 1.0};
  
   auto linear = flutter::DlColorSource::MakeLinear(
       {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
       flutter::DlTileMode::kRepeat);
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setColorSource(linear);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [186/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithTextureCoordinates
	)

Definition at line 238 of file aiks_dl_vertices_unittests.cc.

                                                                    {
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
   };
   std::vector<DlPoint> texture_coordinates = {
       DlPoint(300, 100),
       DlPoint(100, 200),
       DlPoint(300, 300),
   };
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, 3, positions.data(),
       texture_coordinates.data(), /*colors=*/nullptr);
  
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kRed()};
   const float stops[2] = {0.0, 1.0};
  
   auto linear = flutter::DlColorSource::MakeLinear(
       {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
       flutter::DlTileMode::kRepeat);
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setColorSource(linear);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [187/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesPremultipliesColors
	)

Definition at line 358 of file aiks_dl_vertices_unittests.cc.

                                                   {
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
       DlPoint(200, 500),
   };
   auto color = flutter::DlColor::kBlue().withAlpha(0x99);
   std::vector<uint16_t> indices = {0, 1, 2, 0, 2, 3};
   std::vector<flutter::DlColor> colors = {color, color, color, color};
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, positions.size(), positions.data(),
       /*texture_coordinates=*/nullptr, colors.data(), indices.size(),
       indices.data());
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
   paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
   paint.setColor(flutter::DlColor::kRed());
  
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 400), paint);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kDst, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [188/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesSolidColorTrianglesWithIndices
	)

Definition at line 335 of file aiks_dl_vertices_unittests.cc.

                                                              {
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
       DlPoint(200, 500),
   };
   std::vector<uint16_t> indices = {0, 1, 2, 0, 2, 3};
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, positions.size(), positions.data(),
       /*texture_coordinates=*/nullptr, /*colors=*/nullptr, indices.size(),
       indices.data());
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setColor(flutter::DlColor::kRed());
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [189/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesSolidColorTrianglesWithoutIndices
	)

Definition at line 184 of file aiks_dl_vertices_unittests.cc.

                                                                 {
   // Use negative coordinates and then scale the transform by -1, -1 to make
   // sure coverage is taking the transform into account.
   std::vector<DlPoint> positions = {
       DlPoint(-100, -300),
       DlPoint(-200, -100),
       DlPoint(-300, -300),
   };
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kWhite(),
                                           flutter::DlColor::kGreen(),
                                           flutter::DlColor::kWhite()};
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, 3, positions.data(),
       /*texture_coordinates=*/nullptr, colors.data());
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setColor(flutter::DlColor::kRed().modulateOpacity(0.5));
   builder.Scale(-1, -1);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [190/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesTextureCoordinatesWithFragmentShader
	)

Definition at line 417 of file aiks_dl_vertices_unittests.cc.

                                                                    {
   std::vector<DlPoint> positions_lt = {
       DlPoint(0, 0),    //
       DlPoint(50, 0),   //
       DlPoint(0, 50),   //
       DlPoint(50, 50),  //
   };
  
   auto vertices_lt = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangleStrip, positions_lt.size(),
       positions_lt.data(),
       /*texture_coordinates=*/positions_lt.data(), /*colors=*/nullptr,
       /*index_count=*/0,
       /*indices=*/nullptr);
  
   std::vector<DlPoint> positions_rt = {
       DlPoint(50, 0),    //
       DlPoint(100, 0),   //
       DlPoint(50, 50),   //
       DlPoint(100, 50),  //
   };
  
   auto vertices_rt = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangleStrip, positions_rt.size(),
       positions_rt.data(),
       /*texture_coordinates=*/positions_rt.data(), /*colors=*/nullptr,
       /*index_count=*/0,
       /*indices=*/nullptr);
  
   std::vector<DlPoint> positions_lb = {
       DlPoint(0, 50),    //
       DlPoint(50, 50),   //
       DlPoint(0, 100),   //
       DlPoint(50, 100),  //
   };
  
   auto vertices_lb = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangleStrip, positions_lb.size(),
       positions_lb.data(),
       /*texture_coordinates=*/positions_lb.data(), /*colors=*/nullptr,
       /*index_count=*/0,
       /*indices=*/nullptr);
  
   std::vector<DlPoint> positions_rb = {
       DlPoint(50, 50),    //
       DlPoint(100, 50),   //
       DlPoint(50, 100),   //
       DlPoint(100, 100),  //
   };
  
   auto vertices_rb = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangleStrip, positions_rb.size(),
       positions_rb.data(),
       /*texture_coordinates=*/positions_rb.data(), /*colors=*/nullptr,
       /*index_count=*/0,
       /*indices=*/nullptr);
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
   flutter::DlPaint rect_paint;
   rect_paint.setColor(DlColor::kBlue());
  
   auto runtime_stages =
       OpenAssetAsRuntimeStage("runtime_stage_simple.frag.iplr");
  
   auto runtime_stage =
       runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
   ASSERT_TRUE(runtime_stage);
  
   auto runtime_effect = DlRuntimeEffect::MakeImpeller(runtime_stage);
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   auto color_source = flutter::DlColorSource::MakeRuntimeEffect(
       runtime_effect, {}, uniform_data);
  
   paint.setColorSource(color_source);
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.Save();
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), rect_paint);
   builder.DrawVertices(vertices_lt, flutter::DlBlendMode::kSrcOver, paint);
   builder.DrawVertices(vertices_rt, flutter::DlBlendMode::kSrcOver, paint);
   builder.DrawVertices(vertices_lb, flutter::DlBlendMode::kSrcOver, paint);
   builder.DrawVertices(vertices_rb, flutter::DlBlendMode::kSrcOver, paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::PlaygroundBackendToRuntimeStageBackend(), and x.

◆ TEST_P() [191/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesTextureCoordinatesWithFragmentShaderNonZeroOrigin
	)

Definition at line 507 of file aiks_dl_vertices_unittests.cc.

                                                                       {
   std::vector<DlPoint> positions_lt = {
       DlPoint(200, 200),  //
       DlPoint(250, 200),  //
       DlPoint(200, 250),  //
       DlPoint(250, 250),  //
   };
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangleStrip, positions_lt.size(),
       positions_lt.data(),
       /*texture_coordinates=*/positions_lt.data(), /*colors=*/nullptr,
       /*index_count=*/0,
       /*indices=*/nullptr);
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
   flutter::DlPaint rect_paint;
   rect_paint.setColor(DlColor::kBlue());
  
   auto runtime_stages =
       OpenAssetAsRuntimeStage("runtime_stage_position.frag.iplr");
  
   auto runtime_stage =
       runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
   ASSERT_TRUE(runtime_stage);
  
   auto runtime_effect = DlRuntimeEffect::MakeImpeller(runtime_stage);
   auto rect_data = std::vector<Rect>{Rect::MakeLTRB(200, 200, 250, 250)};
  
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(rect_data.size() * sizeof(Rect));
   memcpy(uniform_data->data(), rect_data.data(), uniform_data->size());
  
   auto color_source = flutter::DlColorSource::MakeRuntimeEffect(
       runtime_effect, {}, uniform_data);
  
   paint.setColorSource(color_source);
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawRect(DlRect::MakeLTRB(200, 200, 250, 250), rect_paint);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

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

◆ TEST_P() [192/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesWithEmptyTextureCoordinates
	)

Definition at line 328 of file canvas_unittests.cc.

                                                           {
   auto runtime_stages =
       OpenAssetAsRuntimeStage("runtime_stage_simple.frag.iplr");
  
   auto runtime_stage =
       runtime_stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())];
   ASSERT_TRUE(runtime_stage);
  
   auto runtime_effect = flutter::DlRuntimeEffect::MakeImpeller(runtime_stage);
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   auto color_source = flutter::DlColorSource::MakeRuntimeEffect(
       runtime_effect, {}, uniform_data);
  
   RenderCallback callback = [&](RenderTarget& render_target) {
     ContentContext context(GetContext(), nullptr);
     Canvas canvas(context, render_target, true, false);
  
     std::vector<flutter::DlPoint> vertex_coordinates = {
         flutter::DlPoint(100, 100),
         flutter::DlPoint(300, 100),
         flutter::DlPoint(100, 300),
     };
     // The bounding box of the texture coordinates is empty.
     std::vector<flutter::DlPoint> texture_coordinates = {
         flutter::DlPoint(0, 0),
         flutter::DlPoint(0, 100),
         flutter::DlPoint(0, 0),
     };
     std::vector<uint16_t> indices = {0, 1, 2};
     flutter::DlVertices::Builder vertices_builder(
         flutter::DlVertexMode::kTriangleStrip, vertex_coordinates.size(),
         flutter::DlVertices::Builder::kHasTextureCoordinates, indices.size());
     vertices_builder.store_vertices(vertex_coordinates.data());
     vertices_builder.store_indices(indices.data());
     vertices_builder.store_texture_coordinates(texture_coordinates.data());
     auto vertices = vertices_builder.build();
  
     Paint paint;
     paint.color_source = color_source.get();
     canvas.DrawVertices(std::make_shared<DlVerticesGeometry>(vertices, context),
                         BlendMode::kSrcOver, paint);
  
     canvas.EndReplay();
     return true;
   };
  
   ASSERT_TRUE(Playground::OpenPlaygroundHere(callback));
 }

References impeller::Paint::color_source, impeller::Canvas::DrawVertices(), impeller::Canvas::EndReplay(), impeller::kSrcOver, impeller::Playground::OpenPlaygroundHere(), and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [193/545]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesWithInvalidIndices
	)

Definition at line 385 of file aiks_dl_vertices_unittests.cc.

                                                  {
   std::vector<DlPoint> positions = {
       DlPoint(100, 300),
       DlPoint(200, 100),
       DlPoint(300, 300),
       DlPoint(200, 500),
   };
   std::vector<uint16_t> indices = {0, 1, 2, 0, 2, 3, 99, 100, 101};
  
   auto vertices = flutter::DlVertices::Make(
       flutter::DlVertexMode::kTriangles, positions.size(), positions.data(),
       /*texture_coordinates=*/nullptr, /*colors=*/nullptr, indices.size(),
       indices.data());
  
   EXPECT_EQ(vertices->GetBounds(), DlRect::MakeLTRB(100, 100, 300, 500));
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
   paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
   paint.setColor(flutter::DlColor::kRed());
  
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 400), paint);
   builder.DrawVertices(vertices, flutter::DlBlendMode::kSrc, paint);
  
   AiksContext renderer(GetContext(), nullptr);
   std::shared_ptr<Texture> image =
       DisplayListToTexture(builder.Build(), {1024, 768}, renderer);
   EXPECT_TRUE(image);
 }

References impeller::DisplayListToTexture().

◆ TEST_P() [194/545]

impeller::testing::TEST_P	(	AiksTest	,
		EmptySaveLayerIgnoresPaint
	)

Definition at line 1540 of file aiks_dl_basic_unittests.cc.

                                              {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawPaint(paint);
   builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
   paint.setColor(DlColor::kBlue());
   builder.SaveLayer(std::nullopt, &paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [195/545]

impeller::testing::TEST_P	(	AiksTest	,
		EmptySaveLayerRendersWithClear
	)

Definition at line 1555 of file aiks_dl_basic_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
   builder.DrawImage(image, DlPoint(10, 10), {});
   builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
  
   DlPaint paint;
   paint.setBlendMode(DlBlendMode::kClear);
   builder.SaveLayer(std::nullopt, &paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [196/545]

impeller::testing::TEST_P	(	AiksTest	,
		EmulatedAdvancedBlendRestore
	)

Definition at line 927 of file aiks_dl_blend_unittests.cc.

                                                {
   DisplayListBuilder builder;
  
   builder.DrawPaint(DlPaint(DlColor::kWhite()));
   builder.Save();
   builder.ClipRect(DlRect::MakeLTRB(100, 100, 400, 300));
  
   // Draw should apply the clip, even though it is an advanced blend.
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 300),
                    DlPaint()
                        .setColor(DlColor::kRed())
                        .setBlendMode(DlBlendMode::kDifference));
   // This color should not show if clip is still functional.
   builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100),
                    DlPaint().setColor(DlColor::kBlue()));
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [197/545]

impeller::testing::TEST_P	(	AiksTest	,
		FastEllipticalRRectMaskBlursRenderCorrectly
	)

Definition at line 1957 of file aiks_dl_basic_unittests.cc.

                                                               {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1));
  
   DlPaint save_paint;
   save_paint.setColor(DlColor::kWhite());
   builder.DrawPaint(save_paint);
  
   paint.setColor(DlColor::kBlue());
   for (int i = 0; i < 5; i++) {
     Scalar y = i * 125;
     Scalar y_radius = i * 15;
     for (int j = 0; j < 5; j++) {
       Scalar x = j * 125;
       Scalar x_radius = j * 15;
       builder.DrawRoundRect(
           DlRoundRect::MakeRectXY(
               DlRect::MakeXYWH(x + 50, y + 50, 100.0f, 100.0f),  //
               x_radius, y_radius),
           paint);
     }
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [198/545]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestHorizontal
	)

Definition at line 825 of file aiks_dl_gradient_unittests.cc.

                                              {
   DisplayListBuilder builder;
   DlPaint paint;
   builder.Translate(100.0f, 0);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                  DlColor::kGreen()};
   std::vector<Scalar> stops = {0.0, 0.1, 1.0};
  
   paint.setColorSource(DlColorSource::MakeLinear({0, 0}, {300, 0}, stops.size(),
                                                  colors.data(), stops.data(),
                                                  DlTileMode::kClamp));
  
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
   builder.Translate(400, 0);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [199/545]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestHorizontalReversed
	)

Definition at line 871 of file aiks_dl_gradient_unittests.cc.

                                                      {
   DisplayListBuilder builder;
   DlPaint paint;
   builder.Translate(100.0f, 0);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                  DlColor::kGreen()};
   std::vector<Scalar> stops = {0.0, 0.1, 1.0};
  
   paint.setColorSource(DlColorSource::MakeLinear({300, 0}, {0, 0}, stops.size(),
                                                  colors.data(), stops.data(),
                                                  DlTileMode::kClamp));
  
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
   builder.Translate(400, 0);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [200/545]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestVertical
	)

Definition at line 848 of file aiks_dl_gradient_unittests.cc.

                                            {
   DisplayListBuilder builder;
   DlPaint paint;
   builder.Translate(100.0f, 0);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                  DlColor::kGreen()};
   std::vector<Scalar> stops = {0.0, 0.1, 1.0};
  
   paint.setColorSource(DlColorSource::MakeLinear({0, 0}, {0, 300}, stops.size(),
                                                  colors.data(), stops.data(),
                                                  DlTileMode::kClamp));
  
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
   builder.Translate(400, 0);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [201/545]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestVerticalReversed
	)

Definition at line 894 of file aiks_dl_gradient_unittests.cc.

                                                    {
   DisplayListBuilder builder;
   DlPaint paint;
   builder.Translate(100.0f, 0);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                  DlColor::kGreen()};
   std::vector<Scalar> stops = {0.0, 0.1, 1.0};
  
   paint.setColorSource(DlColorSource::MakeLinear({0, 300}, {0, 0}, stops.size(),
                                                  colors.data(), stops.data(),
                                                  DlTileMode::kClamp));
  
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
   builder.Translate(400, 0);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [202/545]

impeller::testing::TEST_P	(	AiksTest	,
		FatStrokeArc
	)

Definition at line 875 of file aiks_dl_path_unittests.cc.

                                {
   DlScalar stroke_width = 300;
   DlScalar aspect = 1.0;
   DlScalar start_angle = 0;
   DlScalar end_angle = 90;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Stroke Width", &stroke_width, 1, 300);
       ImGui::SliderFloat("Aspect", &aspect, 0.5, 2.0);
       ImGui::SliderFloat("Start Angle", &start_angle, 0, 360);
       ImGui::SliderFloat("End Angle", &end_angle, 0, 360);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     DlPaint grey_paint;
     grey_paint.setColor(DlColor(0xff111111));
     builder.DrawPaint(grey_paint);
  
     DlPaint white_paint;
     white_paint.setColor(DlColor::kWhite());
     white_paint.setStrokeWidth(stroke_width);
     white_paint.setDrawStyle(DlDrawStyle::kStroke);
     DlPaint red_paint;
     red_paint.setColor(DlColor::kRed());
  
     Rect rect = Rect::MakeXYWH(100, 100, 100, aspect * 100);
     builder.DrawRect(rect, red_paint);
     builder.DrawArc(rect, start_angle, end_angle,
                     /*useCenter=*/false, white_paint);
     DlScalar frontier = rect.GetRight() + stroke_width / 2.0;
     builder.DrawLine(Point(frontier, 0), Point(frontier, 150), red_paint);
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::TRect< T >::GetRight(), impeller::AiksPlayground::ImGuiBegin(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [203/545]

impeller::testing::TEST_P	(	AiksTest	,
		FilledArcsRenderCorrectly
	)

Definition at line 791 of file aiks_dl_basic_unittests.cc.

                                             {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [204/545]

impeller::testing::TEST_P	(	AiksTest	,
		FilledArcsRenderCorrectlyWithCenter
	)

Definition at line 808 of file aiks_dl_basic_unittests.cc.

                                                       {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = true,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [205/545]

impeller::testing::TEST_P	(	AiksTest	,
		FilledCirclesRenderCorrectly
	)

Definition at line 562 of file aiks_dl_basic_unittests.cc.

                                                {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   const int color_count = 3;
   DlColor colors[color_count] = {
       DlColor::kBlue(),
       DlColor::kGreen(),
       DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
   };
  
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   int c_index = 0;
   int radius = 600;
   while (radius > 0) {
     paint.setColor(colors[(c_index++) % color_count]);
     builder.DrawCircle(DlPoint(10, 10), radius, paint);
     if (radius > 30) {
       radius -= 10;
     } else {
       radius -= 2;
     }
   }
  
   DlColor gradient_colors[7] = {
       DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
       DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
   };
   DlScalar stops[7] = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
   auto image = DlImageImpeller::Make(texture);
  
   paint.setColorSource(DlColorSource::MakeRadial(
       DlPoint(500, 600), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
   builder.DrawCircle(DlPoint(500, 600), 100, paint);
  
   DlMatrix local_matrix = DlMatrix::MakeTranslation({700, 200});
   paint.setColorSource(DlColorSource::MakeImage(
       image, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kNearestNeighbor, &local_matrix));
   builder.DrawCircle(DlPoint(800, 300), 100, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [206/545]

impeller::testing::TEST_P	(	AiksTest	,
		FilledEllipsesRenderCorrectly
	)

Definition at line 689 of file aiks_dl_basic_unittests.cc.

                                                 {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   const int color_count = 3;
   DlColor colors[color_count] = {
       DlColor::kBlue(),
       DlColor::kGreen(),
       DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
   };
  
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   int c_index = 0;
   int long_radius = 600;
   int short_radius = 600;
   while (long_radius > 0 && short_radius > 0) {
     paint.setColor(colors[(c_index++) % color_count]);
     builder.DrawOval(DlRect::MakeXYWH(10 - long_radius, 10 - short_radius,
                                       long_radius * 2, short_radius * 2),
                      paint);
     builder.DrawOval(DlRect::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;
     }
   }
  
   DlColor gradient_colors[7] = {
       DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
       DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
   };
   DlScalar stops[7] = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
   auto image = DlImageImpeller::Make(texture);
  
   paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
  
   paint.setColorSource(DlColorSource::MakeRadial(
       DlPoint(300, 650), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
   builder.DrawOval(DlRect::MakeXYWH(200, 625, 200, 50), paint);
   builder.DrawOval(DlRect::MakeXYWH(275, 550, 50, 200), paint);
  
   DlMatrix local_matrix = DlMatrix::MakeTranslation({610, 15});
   paint.setColorSource(DlColorSource::MakeImage(
       image, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kNearestNeighbor, &local_matrix));
   builder.DrawOval(DlRect::MakeXYWH(610, 90, 200, 50), paint);
   builder.DrawOval(DlRect::MakeXYWH(685, 15, 50, 200), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [207/545]

impeller::testing::TEST_P	(	AiksTest	,
		FilledRoundRectPathsRenderCorrectly
	)

Definition at line 1691 of file aiks_dl_basic_unittests.cc.

                                                       {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   const int color_count = 3;
   DlColor colors[color_count] = {
       DlColor::kBlue(),
       DlColor::kGreen(),
       DlColor::ARGB(1.0, 220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f),
   };
  
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   auto draw_rrect_as_path = [&builder](const DlRect& rect, Scalar x, Scalar y,
                                        const DlPaint& paint) {
     builder.DrawPath(DlPath::MakeRoundRectXY(rect, x, y), paint);
   };
  
   int c_index = 0;
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 4; j++) {
       paint.setColor(colors[(c_index++) % color_count]);
       draw_rrect_as_path(DlRect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),
                          i * 5 + 10, j * 5 + 10, paint);
     }
   }
   paint.setColor(colors[(c_index++) % color_count]);
   draw_rrect_as_path(DlRect::MakeXYWH(10, 420, 380, 80), 40, 40, paint);
   paint.setColor(colors[(c_index++) % color_count]);
   draw_rrect_as_path(DlRect::MakeXYWH(410, 20, 80, 380), 40, 40, paint);
  
   std::vector<DlColor> gradient_colors = {
       DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
       DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0)};
   std::vector<Scalar> stops = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
   auto texture = DlImageImpeller::Make(
       CreateTextureForFixture("airplane.jpg",
                               /*enable_mipmapping=*/true));
  
   paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
   paint.setColorSource(DlColorSource::MakeRadial(
       /*center=*/DlPoint(550, 550),
       /*radius=*/75,
       /*stop_count=*/gradient_colors.size(),
       /*colors=*/gradient_colors.data(),
       /*stops=*/stops.data(),
       /*tile_mode=*/DlTileMode::kMirror));
   for (int i = 1; i <= 10; i++) {
     int j = 11 - i;
     draw_rrect_as_path(DlRect::MakeLTRB(550 - i * 20, 550 - j * 20,  //
                                         550 + i * 20, 550 + j * 20),
                        i * 10, j * 10, paint);
   }
   paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
   paint.setColorSource(DlColorSource::MakeRadial(
       /*center=*/DlPoint(200, 650),
       /*radius=*/75,
       /*stop_count=*/gradient_colors.size(),
       /*colors=*/gradient_colors.data(),
       /*stops=*/stops.data(),
       /*tile_mode=*/DlTileMode::kMirror));
   draw_rrect_as_path(DlRect::MakeLTRB(100, 610, 300, 690), 40, 40, paint);
   draw_rrect_as_path(DlRect::MakeLTRB(160, 550, 240, 750), 40, 40, paint);
  
   auto matrix = DlMatrix::MakeTranslation({520, 20});
   paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
   paint.setColorSource(DlColorSource::MakeImage(
       texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kMipmapLinear, &matrix));
   for (int i = 1; i <= 10; i++) {
     int j = 11 - i;
     draw_rrect_as_path(DlRect::MakeLTRB(720 - i * 20, 220 - j * 20,  //
                                         720 + i * 20, 220 + j * 20),
                        i * 10, j * 10, paint);
   }
   matrix = DlMatrix::MakeTranslation({800, 300});
   paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
   paint.setColorSource(DlColorSource::MakeImage(
       texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kMipmapLinear, &matrix));
  
   draw_rrect_as_path(DlRect::MakeLTRB(800, 410, 1000, 490), 40, 40, paint);
   draw_rrect_as_path(DlRect::MakeLTRB(860, 350, 940, 550), 40, 40, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [208/545]

impeller::testing::TEST_P	(	AiksTest	,
		FilledRoundRectsRenderCorrectly
	)

Definition at line 1095 of file aiks_dl_basic_unittests.cc.

                                                   {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   const int color_count = 3;
   DlColor colors[color_count] = {
       DlColor::kBlue(),
       DlColor::kGreen(),
       DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
   };
  
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   int c_index = 0;
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 4; j++) {
       paint.setColor(colors[(c_index++) % color_count]);
       builder.DrawRoundRect(
           DlRoundRect::MakeRectXY(
               DlRect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),  //
               i * 5 + 10, j * 5 + 10),
           paint);
     }
   }
   paint.setColor(colors[(c_index++) % color_count]);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(10, 420, 380, 80), 40, 40),
       paint);
   paint.setColor(colors[(c_index++) % color_count]);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(410, 20, 80, 380), 40, 40),
       paint);
  
   DlColor gradient_colors[7] = {
       DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
       DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
   };
   DlScalar stops[7] = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
   auto image = DlImageImpeller::Make(texture);
  
   paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
   paint.setColorSource(DlColorSource::MakeRadial(
       DlPoint(550, 550), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
   for (int i = 1; i <= 10; i++) {
     int j = 11 - i;
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeLTRB(550 - i * 20, 550 - j * 20,  //
                                                  550 + i * 20, 550 + j * 20),
                                 i * 10, j * 10),
         paint);
   }
  
   paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
   paint.setColorSource(DlColorSource::MakeRadial(
       DlPoint(200, 650), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
   paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeLTRB(100, 610, 300, 690), 40, 40),
       paint);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeLTRB(160, 550, 240, 750), 40, 40),
       paint);
  
   paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
   DlMatrix local_matrix = DlMatrix::MakeTranslation({520, 20});
   paint.setColorSource(DlColorSource::MakeImage(
       image, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kNearestNeighbor, &local_matrix));
   for (int i = 1; i <= 10; i++) {
     int j = 11 - i;
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeLTRB(720 - i * 20, 220 - j * 20,  //
                                                  720 + i * 20, 220 + j * 20),
                                 i * 10, j * 10),
         paint);
   }
  
   paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
   local_matrix = DlMatrix::MakeTranslation({800, 300});
   paint.setColorSource(DlColorSource::MakeImage(
       image, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kNearestNeighbor, &local_matrix));
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeLTRB(800, 410, 1000, 490), 40, 40),
       paint);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeLTRB(860, 350, 940, 550), 40, 40),
       paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [209/545]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundAdvancedBlendAppliesTransformCorrectly
	)

Definition at line 732 of file aiks_dl_blend_unittests.cc.

                                                                    {
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
  
   DisplayListBuilder builder;
   builder.Rotate(30);
  
   DlPaint image_paint;
   image_paint.setColorFilter(DlColorFilter::MakeBlend(
       DlColor::RGBA(255.0f / 255.0f, 165.0f / 255.0f, 0.0f / 255.0f, 1.0f),
       DlBlendMode::kColorDodge));
  
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                     DlImageSampling::kMipmapLinear, &image_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [210/545]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundBlendSubpassCollapseOptimization
	)

Definition at line 467 of file aiks_dl_blend_unittests.cc.

                                                              {
   DisplayListBuilder builder;
  
   DlPaint save_paint;
   save_paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kColorDodge));
   builder.SaveLayer(std::nullopt, &save_paint);
  
   builder.Translate(500, 300);
   builder.Rotate(120);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [211/545]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundPipelineBlendAppliesTransformCorrectly
	)

Definition at line 714 of file aiks_dl_blend_unittests.cc.

                                                                    {
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
  
   DisplayListBuilder builder;
   builder.Rotate(30);
  
   DlPaint image_paint;
   image_paint.setColorFilter(DlColorFilter::MakeBlend(
       DlColor::RGBA(255.0f / 255.0f, 165.0f / 255.0f, 0.0f / 255.0f, 1.0f),
       DlBlendMode::kSrcIn));
  
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                     DlImageSampling::kMipmapLinear, &image_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [212/545]

impeller::testing::TEST_P	(	AiksTest	,
		FormatSRGB
	)

Definition at line 1604 of file aiks_dl_basic_unittests.cc.

                              {
   PixelFormat pixel_format =
       GetContext()->GetCapabilities()->GetDefaultColorFormat();
   EXPECT_TRUE(pixel_format == PixelFormat::kR8G8B8A8UNormInt ||
               pixel_format == PixelFormat::kB8G8R8A8UNormInt)
       << "pixel format: " << PixelFormatToString(pixel_format);
 }

References impeller::kB8G8R8A8UNormInt, impeller::kR8G8B8A8UNormInt, and impeller::PixelFormatToString().

◆ TEST_P() [213/545]

impeller::testing::TEST_P	(	AiksTest	,
		FormatWideGamut
	)

Definition at line 1599 of file aiks_dl_basic_unittests.cc.

                                   {
   EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
             PixelFormat::kB10G10R10A10XR);
 }

References impeller::kB10G10R10A10XR.

◆ TEST_P() [214/545]

impeller::testing::TEST_P	(	AiksTest	,
		FramebufferAdvancedBlendCoverage
	)

Definition at line 750 of file aiks_dl_blend_unittests.cc.

                                                    {
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
  
   // Draw with an advanced blend that can use FramebufferBlendContents and
   // verify that the scale transform is correctly applied to the image.
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(
       DlColor::RGBA(169.0f / 255.0f, 169.0f / 255.0f, 169.0f / 255.0f, 1.0f));
   builder.DrawPaint(paint);
   builder.Scale(0.4, 0.4);
  
   DlPaint image_paint;
   image_paint.setBlendMode(DlBlendMode::kMultiply);
  
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(20, 20),
                     DlImageSampling::kMipmapLinear, &image_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [215/545]

impeller::testing::TEST_P	(	AiksTest	,
		FramebufferBlendsRespectClips
	)

If correct, this test should draw a green circle. If any red is visible, there is a depth bug.

Definition at line 118 of file aiks_dl_clip_unittests.cc.

                                                 {
   DisplayListBuilder builder;
  
   // Clear the whole canvas with white.
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   builder.ClipPath(DlPath::MakeCircle(DlPoint(150, 150), 50),
                    DlClipOp::kIntersect);
  
   // Draw a red rectangle that should not show through the circle clip.
   paint.setColor(DlColor::kRed());
   paint.setBlendMode(DlBlendMode::kMultiply);
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 100, 100), paint);
  
   // Draw a green circle that shows through the clip.
   paint.setColor(DlColor::kGreen());
   paint.setBlendMode(DlBlendMode::kSrcOver);
   builder.DrawCircle(DlPoint(150, 150), 50, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [216/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAnimatedBackdrop
	)

Definition at line 851 of file aiks_dl_blur_unittests.cc.

                                                {
   // This test is for checking out how stable rendering is when content is
   // translated underneath a blur.  Animating under a blur can cause
   // *shimmering* to happen as a result of pixel alignment.
   // See also: https://github.com/flutter/flutter/issues/140193
   auto boston =
       CreateTextureForFixture("boston.jpg", /*enable_mipmapping=*/true);
   ASSERT_TRUE(boston);
   int64_t count = 0;
   Scalar sigma = 20.0;
   Scalar freq = 0.1;
   Scalar amp = 50.0;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (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();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     Scalar y = amp * sin(freq * 2.0 * M_PI * count / 60);
     builder.DrawImage(DlImageImpeller::Make(boston),
                       DlPoint(1024 / 2 - boston->GetSize().width / 2,
                               (768 / 2 - boston->GetSize().height / 2) + y),
                       DlImageSampling::kMipmapLinear);
     static PlaygroundPoint point_a(Point(100, 100), 20, Color::Red());
     static PlaygroundPoint point_b(Point(900, 700), 20, Color::Red());
     auto [handle_a, handle_b] = DrawPlaygroundLine(point_a, point_b);
  
     builder.ClipRect(
         DlRect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
     builder.ClipRect(DlRect::MakeLTRB(100, 100, 900, 700));
  
     DlPaint paint;
     paint.setBlendMode(DlBlendMode::kSrc);
  
     auto backdrop_filter =
         DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
     builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
     count += 1;
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundLine(), impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), impeller::Color::Red(), and x.

◆ TEST_P() [217/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAtPeripheryHorizontal
	)

Definition at line 822 of file aiks_dl_blur_unittests.cc.

                                                     {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
   builder.DrawImageRect(
       DlImageImpeller::Make(boston),
       DlRect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height),
       DlRect::MakeLTRB(0, 0, GetWindowSize().width, 100),
       DlImageSampling::kNearestNeighbor);
  
   DlPaint paint;
   paint.setColor(DlColor::kMagenta());
  
   DlRoundRect rrect = DlRoundRect::MakeRectXY(
       DlRect::MakeLTRB(0, 110, GetWindowSize().width, 210), 10, 10);
   builder.DrawRoundRect(rrect, paint);
   builder.ClipRect(DlRect::MakeLTRB(0, 50, GetWindowSize().width, 150));
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kSrc);
  
   auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
   builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
  
   builder.Restore();
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [218/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAtPeripheryVertical
	)

Definition at line 794 of file aiks_dl_blur_unittests.cc.

                                                   {
   DisplayListBuilder builder;
  
   DlPaint paint;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   paint.setColor(DlColor::kLimeGreen());
   DlRoundRect rrect = DlRoundRect::MakeRectXY(
       DlRect::MakeLTRB(0, 0, GetWindowSize().width, 100), 10, 10);
   builder.DrawRoundRect(rrect, paint);
  
   paint.setColor(DlColor::kMagenta());
   rrect = DlRoundRect::MakeRectXY(
       DlRect::MakeLTRB(0, 110, GetWindowSize().width, 210), 10, 10);
   builder.DrawRoundRect(rrect, paint);
   builder.ClipRect(DlRect::MakeLTRB(100, 0, 200, GetWindowSize().height));
  
   DlPaint save_paint;
   save_paint.setBlendMode(DlBlendMode::kSrc);
  
   auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
  
   builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [219/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurBackdropTinyMipMap
	)

Definition at line 1285 of file aiks_dl_blur_unittests.cc.

                                                  {
   AiksContext renderer(GetContext(), nullptr);
   for (int32_t i = 1; i < 5; ++i) {
     DisplayListBuilder builder;
  
     ISize clip_size = ISize(i, i);
     builder.Save();
     builder.ClipRect(
         DlRect::MakeXYWH(400, 400, clip_size.width, clip_size.height));
  
     DlPaint paint;
     paint.setColor(DlColor::kGreen());
     auto blur_filter = DlImageFilter::MakeBlur(0.1, 0.1, DlTileMode::kDecal);
     paint.setImageFilter(blur_filter);
  
     builder.DrawCircle(DlPoint(400, 400), 200, paint);
     builder.Restore();
  
     auto image = DisplayListToTexture(builder.Build(), {1024, 768}, renderer);
     EXPECT_TRUE(image) << " length " << i;
   }
 }

References impeller::DisplayListToTexture(), impeller::TSize< T >::height, and impeller::TSize< T >::width.

◆ TEST_P() [220/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurOneDimension
	)

Definition at line 1097 of file aiks_dl_blur_unittests.cc.

                                            {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.Scale(0.5, 0.5);
  
   std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
   builder.DrawImage(DlImageImpeller::Make(boston), DlPoint(100, 100), {});
  
   DlPaint paint;
   paint.setBlendMode(DlBlendMode::kSrc);
  
   auto backdrop_filter = DlImageFilter::MakeBlur(50, 0, DlTileMode::kClamp);
   builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
   builder.Restore();
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [221/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedAndClipped
	)

Definition at line 1119 of file aiks_dl_blur_unittests.cc.

                                                 {
   DisplayListBuilder builder;
  
   std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
   Rect bounds =
       Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
  
   DlPaint paint;
   paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
  
   Vector2 image_center = Vector2(bounds.GetSize() / 2);
   Vector2 clip_size = {150, 75};
   Vector2 center = Vector2(1024, 768) / 2;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   auto clip_bounds =
       Rect::MakeLTRB(center.x, center.y, center.x, center.y).Expand(clip_size);
   builder.ClipRect(DlRect::MakeLTRB(clip_bounds.GetLeft(), clip_bounds.GetTop(),
                                     clip_bounds.GetRight(),
                                     clip_bounds.GetBottom()));
   builder.Translate(center.x, center.y);
   builder.Scale(0.6, 0.6);
   builder.Rotate(25);
  
   auto dst_rect = bounds.Shift(-image_center);
   builder.DrawImageRect(
       DlImageImpeller::Make(boston), /*src=*/
       DlRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(), bounds.GetRight(),
                        bounds.GetBottom()),
       /*dst=*/
       DlRect::MakeLTRB(dst_rect.GetLeft(), dst_rect.GetTop(),
                        dst_rect.GetRight(), dst_rect.GetBottom()),
       DlImageSampling::kMipmapLinear, &paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::TRect< T >::Expand(), impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetTop(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), impeller::TRect< T >::Shift(), x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [222/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedAndClippedInteractive
	)

Definition at line 1042 of file aiks_dl_blur_unittests.cc.

                                                            {
   std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  
   auto callback = [&]() -> sk_sp<DisplayList> {
     const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
     const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                      DlTileMode::kMirror, DlTileMode::kDecal};
  
     static float rotation = 0;
     static float scale = 0.6;
     static int selected_tile_mode = 3;
  
     if (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();
     }
  
     DisplayListBuilder builder;
     Rect bounds =
         Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
     Vector2 image_center = Vector2(bounds.GetSize() / 2);
     DlPaint paint;
     paint.setImageFilter(
         DlImageFilter::MakeBlur(20, 20, tile_modes[selected_tile_mode]));
  
     static PlaygroundPoint point_a(Point(362, 309), 20, Color::Red());
     static PlaygroundPoint point_b(Point(662, 459), 20, Color::Red());
     auto [handle_a, handle_b] = DrawPlaygroundLine(point_a, point_b);
     Vector2 center = Vector2(1024, 768) / 2;
  
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.ClipRect(
         DlRect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
     builder.Translate(center.x, center.y);
     builder.Scale(scale, scale);
     builder.Rotate(rotation);
  
     DlRect sk_bounds = DlRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(),
                                         bounds.GetRight(), bounds.GetBottom());
     Rect dest = bounds.Shift(-image_center);
     DlRect sk_dst = DlRect::MakeLTRB(dest.GetLeft(), dest.GetTop(),
                                      dest.GetRight(), dest.GetBottom());
     builder.DrawImageRect(DlImageImpeller::Make(boston), /*src=*/sk_bounds,
                           /*dst=*/sk_dst, DlImageSampling::kNearestNeighbor,
                           &paint);
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundLine(), impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetTop(), impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Color::Red(), impeller::TPoint< T >::Rotate(), impeller::TRect< T >::Shift(), x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [223/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedNonUniform
	)

Definition at line 1156 of file aiks_dl_blur_unittests.cc.

                                                 {
   auto callback = [&]() -> sk_sp<DisplayList> {
     const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
     const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                      DlTileMode::kMirror, DlTileMode::kDecal};
  
     static float rotation = 45;
     static float scale = 0.6;
     static int selected_tile_mode = 3;
  
     if (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();
     }
  
     DisplayListBuilder builder;
  
     DlPaint paint;
     paint.setColor(DlColor::kGreen());
     paint.setImageFilter(
         DlImageFilter::MakeBlur(50, 0, tile_modes[selected_tile_mode]));
  
     Vector2 center = Vector2(1024, 768) / 2;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.Translate(center.x, center.y);
     builder.Scale(scale, scale);
     builder.Rotate(rotation);
  
     DlRoundRect rrect =
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(-100, -100, 200, 200), 10, 10);
     builder.DrawRoundRect(rrect, paint);
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::TPoint< T >::Rotate(), x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [224/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurScaledAndClipped
	)

Definition at line 1009 of file aiks_dl_blur_unittests.cc.

                                                {
   DisplayListBuilder builder;
   std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
   Rect bounds =
       Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
   Vector2 image_center = Vector2(bounds.GetSize() / 2);
  
   DlPaint paint;
   paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
  
   Vector2 clip_size = {150, 75};
   Vector2 center = Vector2(1024, 768) / 2;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   auto rect =
       Rect::MakeLTRB(center.x, center.y, center.x, center.y).Expand(clip_size);
   builder.ClipRect(DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),
                                     rect.GetRight(), rect.GetBottom()));
   builder.Translate(center.x, center.y);
   builder.Scale(0.6, 0.6);
  
   DlRect sk_bounds = DlRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(),
                                       bounds.GetRight(), bounds.GetBottom());
   Rect dest = bounds.Shift(-image_center);
   DlRect sk_dst = DlRect::MakeLTRB(dest.GetLeft(), dest.GetTop(),
                                    dest.GetRight(), dest.GetBottom());
   builder.DrawImageRect(DlImageImpeller::Make(boston), /*src=*/sk_bounds,
                         /*dst=*/sk_dst, DlImageSampling::kNearestNeighbor,
                         &paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::TRect< T >::Expand(), impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetTop(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), impeller::TRect< T >::Shift(), x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [225/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurSolidColorTinyMipMap
	)

Definition at line 1260 of file aiks_dl_blur_unittests.cc.

                                                    {
   AiksContext renderer(GetContext(), nullptr);
  
   for (int32_t i = 1; i < 5; ++i) {
     DisplayListBuilder builder;
     Scalar fi = i;
     DlPathBuilder path_builder;
     path_builder.MoveTo(DlPoint(100, 100));
     path_builder.LineTo(DlPoint(100 + fi, 100 + fi));
  
     DlPaint paint;
     paint.setColor(DlColor::kChartreuse());
     auto blur_filter = DlImageFilter::MakeBlur(0.1, 0.1, DlTileMode::kClamp);
     paint.setImageFilter(blur_filter);
  
     builder.DrawPath(path_builder.TakePath(), paint);
  
     auto image = DisplayListToTexture(builder.Build(), {1024, 768}, renderer);
     EXPECT_TRUE(image) << " length " << i;
   }
 }

References impeller::DisplayListToTexture().

◆ TEST_P() [226/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleInner
	)

Definition at line 649 of file aiks_dl_blur_unittests.cc.

                                          {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1));
   builder.DrawPaint(paint);
  
   paint.setColor(DlColor::kGreen());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kInner, 30));
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(300, 400));
   path_builder.LineTo(DlPoint(100, 400));
   path_builder.Close();
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Draw another thing to make sure the clip area is reset.
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [227/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleInnerGradient
	)

Definition at line 899 of file aiks_dl_blur_unittests.cc.

                                                  {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                  DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   paint = DlPaint{};
   paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/{0, 0},
       /*end_point=*/{200, 200},
       /*stop_count=*/colors.size(),
       /*colors=*/colors.data(),
       /*stops=*/stops.data(),
       /*tile_mode=*/DlTileMode::kMirror));
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kInner, 30));
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(300, 400));
   path_builder.LineTo(DlPoint(100, 400));
   path_builder.Close();
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Draw another thing to make sure the clip area is reset.
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [228/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleOuter
	)

Definition at line 676 of file aiks_dl_blur_unittests.cc.

                                          {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   paint.setColor(DlColor::kGreen());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kOuter, 30));
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(300, 400));
   path_builder.LineTo(DlPoint(100, 400));
   path_builder.Close();
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Draw another thing to make sure the clip area is reset.
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [229/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleOuterGradient
	)

Definition at line 973 of file aiks_dl_blur_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                  DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   paint = DlPaint{};
   paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/{0, 0},
       /*end_point=*/{200, 200},
       /*stop_count=*/colors.size(),
       /*colors=*/colors.data(),
       /*stops=*/stops.data(),
       /*tile_mode=*/DlTileMode::kMirror));
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kOuter, 30));
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(300, 400));
   path_builder.LineTo(DlPoint(100, 400));
   path_builder.Close();
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Draw another thing to make sure the clip area is reset.
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [230/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleSolid
	)

Definition at line 703 of file aiks_dl_blur_unittests.cc.

                                          {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   paint.setColor(DlColor::kGreen());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kSolid, 30));
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(300, 400));
   path_builder.LineTo(DlPoint(100, 400));
   path_builder.Close();
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Draw another thing to make sure the clip area is reset.
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [231/545]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleSolidGradient
	)

Definition at line 937 of file aiks_dl_blur_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                  DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
   std::vector<Scalar> stops = {0.0, 1.0};
  
   paint = DlPaint{};
   paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/{0, 0},
       /*end_point=*/{200, 200},
       /*stop_count=*/colors.size(),
       /*colors=*/colors.data(),
       /*stops=*/stops.data(),
       /*tile_mode=*/DlTileMode::kMirror));
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kSolid, 30));
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(300, 400));
   path_builder.LineTo(DlPoint(100, 400));
   path_builder.Close();
   builder.DrawPath(path_builder.TakePath(), paint);
  
   // Draw another thing to make sure the clip area is reset.
   DlPaint red;
   red.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [232/545]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlur
	)

Definition at line 103 of file aiks_dl_blur_unittests.cc.

                                              {
   ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
       GetContentScale(), /*sigma=*/10, DlBlurStyle::kNormal)));
 }

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [233/545]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurInner
	)

Definition at line 118 of file aiks_dl_blur_unittests.cc.

                                                   {
   ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
       GetContentScale(), /*sigma=*/10, DlBlurStyle::kInner)));
 }

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [234/545]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurOuter
	)

Definition at line 113 of file aiks_dl_blur_unittests.cc.

                                                   {
   ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
       GetContentScale(), /*sigma=*/10, DlBlurStyle::kOuter)));
 }

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [235/545]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurSigmaZero
	)

Definition at line 108 of file aiks_dl_blur_unittests.cc.

                                                       {
   ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
       GetContentScale(), /*sigma=*/0, DlBlurStyle::kNormal)));
 }

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [236/545]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurSolid
	)

Definition at line 123 of file aiks_dl_blur_unittests.cc.

                                                   {
   ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
       GetContentScale(), /*sigma=*/10, DlBlurStyle::kSolid)));
 }

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [237/545]

impeller::testing::TEST_P	(	AiksTest	,
		GradientStrokesRenderCorrectly
	)

Definition at line 734 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));
  
     DlPathBuilder path_builder;
     path_builder.MoveTo(DlPoint(20, 20));
     path_builder.QuadraticCurveTo(DlPoint(60, 20), DlPoint(60, 60));
     path_builder.Close();
     path_builder.MoveTo(DlPoint(60, 20));
     path_builder.QuadraticCurveTo(DlPoint(60, 60), DlPoint(20, 60));
     DlPath path = path_builder.TakePath();
  
     builder.Scale(scale, scale);
  
     if (add_circle_clip) {
       static PlaygroundPoint circle_clip_point_a(Point(60, 300), 20,
                                                  Color::Red());
       static PlaygroundPoint circle_clip_point_b(Point(600, 300), 20,
                                                  Color::Red());
       auto [handle_a, handle_b] =
           DrawPlaygroundLine(circle_clip_point_a, circle_clip_point_b);
  
       Matrix ip_matrix = builder.GetMatrix();
       if (!ip_matrix.IsInvertible()) {
         return nullptr;
       }
       ip_matrix = ip_matrix.Invert();
       Point point_a = ip_matrix * handle_a * GetContentScale();
       Point point_b = ip_matrix * handle_b * GetContentScale();
  
       Point middle = (point_a + point_b) / 2;
       auto radius = point_a.GetDistance(middle);
       builder.ClipPath(DlPath::MakeCircle(middle, radius));
     }
  
     for (auto join :
          {DlStrokeJoin::kBevel, DlStrokeJoin::kRound, DlStrokeJoin::kMiter}) {
       paint.setStrokeJoin(join);
       for (auto cap :
            {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
         paint.setStrokeCap(cap);
         builder.DrawPath(path, paint);
         builder.Translate(80, 0);
       }
       builder.Translate(-240, 60);
     }
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundLine(), impeller::TPoint< T >::GetDistance(), impeller::Matrix::Invert(), impeller::Matrix::IsInvertible(), impeller::Color::ToARGB(), and x.

◆ TEST_P() [238/545]

impeller::testing::TEST_P	(	AiksTest	,
		HairlineDrawLine
	)

Definition at line 308 of file aiks_dl_path_unittests.cc.

                                    {
   Scalar scale = 1.f;
   Scalar rotation = 0.f;
   Scalar offset = 0.f;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Scale", &scale, 0, 6);
       ImGui::SliderFloat("Rotate", &rotation, 0, 90);
       ImGui::SliderFloat("Offset", &offset, 0, 2);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.DrawPaint(DlPaint(DlColor(0xff111111)));
  
     DlPaint paint;
     paint.setStrokeWidth(0.f);
     paint.setColor(DlColor::kWhite());
  
     builder.Translate(512, 384);
     builder.Scale(scale, scale);
     builder.Rotate(rotation);
     builder.Translate(-512, -384 + offset);
  
     for (int i = 0; i < 5; ++i) {
       Scalar yoffset = i * 25.25f + 300.f;
  
       builder.DrawLine(DlPoint(100, yoffset), DlPoint(924, yoffset), paint);
     }
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), and x.

◆ TEST_P() [239/545]

impeller::testing::TEST_P	(	AiksTest	,
		HairlinePath
	)

Definition at line 264 of file aiks_dl_path_unittests.cc.

                                {
   Scalar scale = 1.f;
   Scalar rotation = 0.f;
   Scalar offset = 0.f;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Scale", &scale, 0, 6);
       ImGui::SliderFloat("Rotate", &rotation, 0, 90);
       ImGui::SliderFloat("Offset", &offset, 0, 2);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.DrawPaint(DlPaint(DlColor(0xff111111)));
  
     DlPaint paint;
     paint.setStrokeWidth(0.f);
     paint.setColor(DlColor::kWhite());
     paint.setStrokeCap(DlStrokeCap::kRound);
     paint.setStrokeJoin(DlStrokeJoin::kRound);
     paint.setDrawStyle(DlDrawStyle::kStroke);
  
     builder.Translate(512, 384);
     builder.Scale(scale, scale);
     builder.Rotate(rotation);
     builder.Translate(-512, -384 + offset);
  
     for (int i = 0; i < 5; ++i) {
       Scalar yoffset = i * 25.25f + 300.f;
       DlPathBuilder path_builder;
  
       path_builder.MoveTo(DlPoint(100, yoffset));
       path_builder.LineTo(DlPoint(924, yoffset));
       builder.DrawPath(path_builder.TakePath(), paint);
     }
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), and x.

◆ TEST_P() [240/545]

impeller::testing::TEST_P	(	AiksTest	,
		HexagonExperimentAntialiasLines
	)

Definition at line 680 of file aiks_dl_path_unittests.cc.

                                                   {
   float scale = 5.0f;
   float line_width = 10.f;
   float rotation = 0.f;
  
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       // Use ImGui::SliderFloat for consistency
       ImGui::SliderFloat("Scale", &scale, 0.001f, 5.0f);
       ImGui::SliderFloat("Width", &line_width, 1.0f, 20.0f);
       ImGui::SliderFloat("Rotation", &rotation, 0.0f, 180.0f);
  
       ImGui::End();
     }
     DisplayListBuilder builder;
     builder.Scale(static_cast<float>(GetContentScale().x),
                   static_cast<float>(GetContentScale().y));
  
     builder.DrawPaint(DlPaint(DlColor(0xff111111)));  // Background
  
     {
       DlPaint hex_paint;
       hex_paint.setColor(
           DlColor::kGreen());  // Changed color to Red for visibility
       hex_paint.setStrokeWidth(line_width);  // Use the interactive width
  
       float cx = 512.0f;  // Center X
       float cy = 384.0f;  // Center Y
       float r = 80.0f;    // Radius (distance from center to vertex)
  
       float r_sin60 = r * std::sqrt(3.0f) / 2.0f;
       float r_cos60 = r / 2.0f;
  
       DlPoint v0 = DlPoint(cx + r, cy);                  // Right vertex
       DlPoint v1 = DlPoint(cx + r_cos60, cy - r_sin60);  // Top-right vertex
       DlPoint v2 = DlPoint(
           cx - r_cos60,
           cy - r_sin60);  // Top-left vertex (v1-v2 is top horizontal side)
       DlPoint v3 = DlPoint(cx - r, cy);                  // Left vertex
       DlPoint v4 = DlPoint(cx - r_cos60, cy + r_sin60);  // Bottom-left vertex
       DlPoint v5 =
           DlPoint(cx + r_cos60, cy + r_sin60);  // Bottom-right vertex (v4-v5 is
                                                 // bottom horizontal side)
  
       builder.Translate(cx, cy);
       builder.Scale(scale, scale);
       builder.Rotate(rotation);
       builder.Translate(-cx, -cy);
  
       builder.DrawLine(v0, v1, hex_paint);
       builder.DrawLine(v1, v2, hex_paint);  // Top side
       builder.DrawLine(v2, v3, hex_paint);
       builder.DrawLine(v3, v4, hex_paint);
       builder.DrawLine(v4, v5, hex_paint);  // Bottom side
       builder.DrawLine(v5, v0, hex_paint);  // Close the hexagon
     }
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), and x.

◆ TEST_P() [241/545]

impeller::testing::TEST_P	(	AiksTest	,
		ImageColorSourceEffectTransform
	)

Definition at line 1368 of file aiks_dl_basic_unittests.cc.

                                                   {
   // Compare with https://fiddle.skia.org/c/6cdc5aefb291fda3833b806ca347a885
  
   DisplayListBuilder builder;
   auto texture = DlImageImpeller::Make(CreateTextureForFixture("monkey.png"));
  
   DlPaint paint;
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   // Translation
   {
     DlMatrix matrix = DlMatrix::MakeTranslation({50, 50});
     DlPaint paint;
     paint.setColorSource(DlColorSource::MakeImage(
         texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
         DlImageSampling::kNearestNeighbor, &matrix));
  
     builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
   }
  
   // Rotation/skew
   {
     builder.Save();
     builder.Rotate(45);
     DlPaint paint;
  
     Matrix matrix(1, -1, 0, 0,  //
                   1, 1, 0, 0,   //
                   0, 0, 1, 0,   //
                   0, 0, 0, 1);
     paint.setColorSource(DlColorSource::MakeImage(
         texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
         DlImageSampling::kNearestNeighbor, &matrix));
     builder.DrawRect(DlRect::MakeLTRB(100, 0, 200, 100), paint);
     builder.Restore();
   }
  
   // Scale
   {
     builder.Save();
     builder.Translate(100, 0);
     builder.Scale(100, 100);
     DlPaint paint;
  
     DlMatrix matrix = DlMatrix::MakeScale({0.005, 0.005, 1});
     paint.setColorSource(DlColorSource::MakeImage(
         texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
         DlImageSampling::kNearestNeighbor, &matrix));
  
     builder.DrawRect(DlRect::MakeLTRB(0, 0, 1, 1), paint);
     builder.Restore();
   }
  
   // Perspective
   {
     builder.Save();
     builder.Translate(150, 150);
     DlPaint paint;
  
     DlMatrix matrix =
         DlMatrix::MakePerspective(Radians{0.5}, ISize{200, 200}, 0.05, 1);
     paint.setColorSource(DlColorSource::MakeImage(
         texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
         DlImageSampling::kNearestNeighbor, &matrix));
  
     builder.DrawRect(DlRect::MakeLTRB(0, 0, 200, 200), paint);
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [242/545]

impeller::testing::TEST_P	(	AiksTest	,
		ImageFilteredSaveLayerWithUnboundedContents
	)

Definition at line 661 of file aiks_dl_unittests.cc.

                                                               {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   auto test = [&builder](const std::shared_ptr<DlImageFilter>& filter) {
     auto DrawLine = [&builder](const DlPoint& p0, const DlPoint& p1,
                                const DlPaint& p) {
       DlPaint paint = p;
       paint.setDrawStyle(DlDrawStyle::kStroke);
       builder.DrawPath(DlPath::MakeLine(p0, p1), paint);
     };
     // Registration marks for the edge of the SaveLayer
     DlPaint paint;
     paint.setColor(DlColor::kWhite());
     DrawLine(DlPoint(75, 100), DlPoint(225, 100), paint);
     DrawLine(DlPoint(75, 200), DlPoint(225, 200), paint);
     DrawLine(DlPoint(100, 75), DlPoint(100, 225), paint);
     DrawLine(DlPoint(200, 75), DlPoint(200, 225), paint);
  
     DlPaint save_paint;
     save_paint.setImageFilter(filter);
     DlRect bounds = DlRect::MakeLTRB(100, 100, 200, 200);
     builder.SaveLayer(bounds, &save_paint);
  
     {
       // DrawPaint to verify correct behavior when the contents are unbounded.
       DlPaint paint;
       paint.setColor(DlColor::kYellow());
       builder.DrawPaint(paint);
  
       // Contrasting rectangle to see interior blurring
       paint.setColor(DlColor::kBlue());
       builder.DrawRect(DlRect::MakeLTRB(125, 125, 175, 175), paint);
     }
     builder.Restore();
   };
  
   test(DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal));
  
   builder.Translate(200.0, 0.0);
  
   test(DlImageFilter::MakeDilate(10.0, 10.0));
  
   builder.Translate(200.0, 0.0);
  
   test(DlImageFilter::MakeErode(10.0, 10.0));
  
   builder.Translate(-400.0, 200.0);
  
   DlMatrix matrix = DlMatrix::MakeRotationZ(DlDegrees(10));
  
   auto rotate_filter =
       DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear);
   test(rotate_filter);
  
   builder.Translate(200.0, 0.0);
  
   const float m[20] = {
       0, 1, 0, 0, 0,  //
       0, 0, 1, 0, 0,  //
       1, 0, 0, 0, 0,  //
       0, 0, 0, 1, 0   //
   };
   auto rgb_swap_filter =
       DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(m));
   test(rgb_swap_filter);
  
   builder.Translate(200.0, 0.0);
  
   test(DlImageFilter::MakeCompose(rotate_filter, rgb_swap_filter));
  
   builder.Translate(-400.0, 200.0);
  
   test(rotate_filter->makeWithLocalMatrix(
       DlMatrix::MakeTranslation({25.0, 25.0})));
  
   builder.Translate(200.0, 0.0);
  
   test(rgb_swap_filter->makeWithLocalMatrix(
       DlMatrix::MakeTranslation({25.0, 25.0})));
  
   builder.Translate(200.0, 0.0);
  
   test(DlImageFilter::MakeCompose(rotate_filter, rgb_swap_filter)
            ->makeWithLocalMatrix(DlMatrix::MakeTranslation({25.0, 25.0})));
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [243/545]

impeller::testing::TEST_P	(	AiksTest	,
		ImageFilteredUnboundedSaveLayerWithUnboundedContents
	)

Definition at line 225 of file aiks_dl_unittests.cc.

                                                                        {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint save_paint;
   save_paint.setImageFilter(
       DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal));
   builder.SaveLayer(std::nullopt, &save_paint);
  
   {
     // DrawPaint to verify correct behavior when the contents are unbounded.
     DlPaint draw_paint;
     draw_paint.setColor(DlColor::kYellow());
     builder.DrawPaint(draw_paint);
  
     // Contrasting rectangle to see interior blurring
     DlPaint draw_rect;
     draw_rect.setColor(DlColor::kBlue());
     builder.DrawRect(DlRect::MakeLTRB(125, 125, 175, 175), draw_rect);
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [244/545]

impeller::testing::TEST_P	(	AiksTest	,
		LinearToSrgbFilterSubpassCollapseOptimization
	)

Definition at line 105 of file aiks_dl_unittests.cc.

                                                                 {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColorFilter(DlColorFilter::MakeLinearToSrgbGamma());
   builder.SaveLayer(std::nullopt, &paint);
  
   builder.Translate(500, 300);
   builder.Rotate(120);  // 120 deg.
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), draw_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [245/545]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurDoesntStretchContents
	)

Definition at line 759 of file aiks_dl_blur_unittests.cc.

                                                 {
   Scalar sigma = 70;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Sigma", &sigma, 0, 500);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     DlPaint paint;
     paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
     builder.DrawPaint(paint);
  
     std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  
     builder.Transform(Matrix::MakeTranslation({100, 100}) *
                       Matrix::MakeScale({0.5, 0.5, 1.0f}));
  
     paint.setColorSource(DlColorSource::MakeImage(
         DlImageImpeller::Make(boston), DlTileMode::kRepeat, DlTileMode::kRepeat,
         DlImageSampling::kMipmapLinear));
     paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
  
     builder.DrawRect(DlRect::MakeXYWH(0, 0, boston->GetSize().width,
                                       boston->GetSize().height),
                      paint);
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and x.

◆ TEST_P() [246/545]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurOnZeroDimensionIsSkippedWideGamut
	)

Definition at line 474 of file aiks_dl_blur_unittests.cc.

                                                             {
   // Making sure this test is run on a wide gamut enabled backend
   EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
             PixelFormat::kB10G10R10A10XR);
  
   DisplayListBuilder builder;
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10));
  
   // Zero height above
   builder.DrawRect(DlRect::MakeLTRB(100, 250, 500, 250), paint);
   // Regular rect
   builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
   // Zero width to the right
   builder.DrawRect(DlRect::MakeLTRB(550, 300, 550, 600), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::kB10G10R10A10XR.

◆ TEST_P() [247/545]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurTexture
	)

Definition at line 730 of file aiks_dl_blur_unittests.cc.

                                   {
   Scalar sigma = 30;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Sigma", &sigma, 0, 500);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     DlPaint paint;
     paint.setColor(DlColor::kGreen());
     paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
  
     builder.DrawImage(
         DlImageImpeller::Make(CreateTextureForFixture("boston.jpg")),
         DlPoint(200, 200), DlImageSampling::kNearestNeighbor, &paint);
  
     DlPaint red;
     red.setColor(DlColor::kRed());
     builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [248/545]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurWithZeroSigmaIsSkipped
	)

Definition at line 461 of file aiks_dl_blur_unittests.cc.

                                                  {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 0));
  
   builder.DrawCircle(DlPoint(300, 300), 200, paint);
   builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [249/545]

impeller::testing::TEST_P	(	AiksTest	,
		MassiveScaleConvertToPath
	)

Definition at line 195 of file aiks_dl_text_unittests.cc.

                                             {
   Scalar scale = 16.0;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Scale", &scale, 4, 20);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     DlPaint paint;
     paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
     builder.DrawPaint(paint);
  
     builder.Scale(scale, scale);
     RenderTextInCanvasSkia(
         GetContext(), builder, "HELLO", "Roboto-Regular.ttf",
         TextRenderOptions{.font_size = 16,
                           .color = (16 * scale >= 250) ? DlColor::kYellow()
                                                        : DlColor::kOrange(),
                           .position = DlPoint(0, 20)});
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::testing::TextRenderOptions::font_size, and RenderTextInCanvasSkia().

◆ TEST_P() [250/545]

impeller::testing::TEST_P	(	AiksTest	,
		MassiveScalingMatrixImageFilter
	)

Definition at line 2012 of file aiks_dl_basic_unittests.cc.

                                                   {
   if (GetBackend() == PlaygroundBackend::kVulkan) {
     GTEST_SKIP() << "Swiftshader is running out of memory on this example.";
   }
   DisplayListBuilder builder(DlRect::MakeSize(DlSize(1000, 1000)));
  
   auto filter = DlImageFilter::MakeMatrix(
       DlMatrix::MakeScale({0.001, 0.001, 1}), DlImageSampling::kLinear);
  
   DlPaint paint;
   paint.setImageFilter(filter);
   builder.SaveLayer(std::nullopt, &paint);
   {
     DlPaint paint;
     paint.setColor(DlColor::kRed());
     builder.DrawRect(DlRect::MakeLTRB(0, 0, 100000, 100000), paint);
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::kVulkan.

◆ TEST_P() [251/545]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixBackdropFilter
	)

Definition at line 750 of file aiks_dl_unittests.cc.

                                        {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kBlack());
   builder.DrawPaint(paint);
   builder.SaveLayer(std::nullopt, nullptr);
   {
     DlPaint paint;
     paint.setColor(DlColor::kGreen().withAlpha(0.5 * 255));
     paint.setBlendMode(DlBlendMode::kPlus);
  
     DlPaint rect_paint;
     rect_paint.setColor(DlColor::kRed());
     rect_paint.setStrokeWidth(4);
     rect_paint.setDrawStyle(DlDrawStyle::kStroke);
     builder.DrawRect(DlRect::MakeLTRB(0, 0, 300, 300), rect_paint);
     builder.DrawCircle(DlPoint(200, 200), 100, paint);
     // Should render a second circle, centered on the bottom-right-most edge of
     // the circle.
     DlMatrix matrix = DlMatrix::MakeTranslation({(100 + 100 * k1OverSqrt2),
                                                  (100 + 100 * k1OverSqrt2)}) *
                       DlMatrix::MakeScale({0.5, 0.5, 1}) *
                       DlMatrix::MakeTranslation({-100, -100});
     auto backdrop_filter =
         DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear);
     builder.SaveLayer(std::nullopt, nullptr, backdrop_filter.get());
     builder.Restore();
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::k1OverSqrt2.

◆ TEST_P() [252/545]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen
	)

Definition at line 1491 of file aiks_dl_basic_unittests.cc.

                                                                         {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.Translate(100, 100);
   // Draw a circle in a SaveLayer at -300, but move it back on-screen with a
   // +300 translation applied by a SaveLayer image filter.
  
   DlPaint paint;
   paint.setImageFilter(DlImageFilter::MakeMatrix(
       DlMatrix::MakeTranslation({300, 0}) * DlMatrix::MakeScale({2, 2, 1}),
       DlImageSampling::kNearestNeighbor));
   builder.SaveLayer(std::nullopt, &paint);
  
   DlPaint circle_paint;
   circle_paint.setColor(DlColor::kGreen());
   builder.DrawCircle(DlPoint(-150, 0), 50, circle_paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [253/545]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen
	)

Definition at line 1470 of file aiks_dl_basic_unittests.cc.

                                                                          {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.Translate(100, 100);
   // Draw a circle in a SaveLayer at -300, but move it back on-screen with a
   // +300 translation applied by a SaveLayer image filter.
   DlPaint paint;
   DlMatrix translate = DlMatrix::MakeTranslation({300, 0});
   paint.setImageFilter(
       DlImageFilter::MakeMatrix(translate, DlImageSampling::kLinear));
   builder.SaveLayer(std::nullopt, &paint);
  
   DlPaint circle_paint;
   circle_paint.setColor(DlColor::kGreen());
   builder.DrawCircle(DlPoint(-300, 0), 100, circle_paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [254/545]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterMagnify
	)

Definition at line 629 of file aiks_dl_unittests.cc.

                                            {
   Scalar scale = 2.0;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Scale", &scale, 1, 2);
       ImGui::End();
     }
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
  
     builder.Translate(600, -200);
  
     DlMatrix matrix = DlMatrix::MakeScale({scale, scale, 1});
     DlPaint paint;
     paint.setImageFilter(
         DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear));
     builder.SaveLayer(std::nullopt, &paint);
  
     DlPaint rect_paint;
     rect_paint.setAlpha(0.5 * 255);
     builder.DrawImage(image, DlPoint(0, 0), DlImageSampling::kLinear,
                       &rect_paint);
     builder.Restore();
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [255/545]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixSaveLayerFilter
	)

Definition at line 784 of file aiks_dl_unittests.cc.

                                         {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kBlack());
   builder.DrawPaint(paint);
   builder.SaveLayer(std::nullopt, nullptr);
   {
     paint.setColor(DlColor::kGreen().withAlpha(255 * 0.5));
     paint.setBlendMode(DlBlendMode::kPlus);
     builder.DrawCircle(DlPoint(200, 200), 100, paint);
     // Should render a second circle, centered on the bottom-right-most edge of
     // the circle.
  
     DlMatrix matrix = DlMatrix::MakeTranslation({(200 + 100 * k1OverSqrt2),
                                                  (200 + 100 * k1OverSqrt2)}) *
                       DlMatrix::MakeScale({0.5, 0.5, 1}) *
                       DlMatrix::MakeTranslation({-200, -200});
     DlPaint save_paint;
     save_paint.setImageFilter(
         DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear));
  
     builder.SaveLayer(std::nullopt, &save_paint);
  
     DlPaint circle_paint;
     circle_paint.setColor(DlColor::kGreen().withAlpha(255 * 0.5));
     circle_paint.setBlendMode(DlBlendMode::kPlus);
     builder.DrawCircle(DlPoint(200, 200), 100, circle_paint);
     builder.Restore();
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::k1OverSqrt2.

◆ TEST_P() [256/545]

impeller::testing::TEST_P	(	AiksTest	,
		MipmapGenerationWorksCorrectly
	)

Definition at line 481 of file aiks_dl_unittests.cc.

                                                  {
   TextureDescriptor texture_descriptor;
   texture_descriptor.size = ISize{1024, 1024};
   texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
   texture_descriptor.storage_mode = StorageMode::kHostVisible;
   texture_descriptor.mip_count = texture_descriptor.size.MipCount();
  
   std::vector<uint8_t> bytes(4194304);
   bool alternate = false;
   for (auto i = 0u; i < 4194304; i += 4) {
     if (alternate) {
       bytes[i] = 255;
       bytes[i + 1] = 0;
       bytes[i + 2] = 0;
       bytes[i + 3] = 255;
     } else {
       bytes[i] = 0;
       bytes[i + 1] = 255;
       bytes[i + 2] = 0;
       bytes[i + 3] = 255;
     }
     alternate = !alternate;
   }
  
   ASSERT_EQ(texture_descriptor.GetByteSizeOfBaseMipLevel(), bytes.size());
   auto mapping = std::make_shared<fml::NonOwnedMapping>(
       bytes.data(),                                   // data
       texture_descriptor.GetByteSizeOfBaseMipLevel()  // size
   );
   auto texture =
       GetContext()->GetResourceAllocator()->CreateTexture(texture_descriptor);
  
   auto device_buffer =
       GetContext()->GetResourceAllocator()->CreateBufferWithCopy(*mapping);
   auto command_buffer = GetContext()->CreateCommandBuffer();
   auto blit_pass = command_buffer->CreateBlitPass();
  
   blit_pass->AddCopy(DeviceBuffer::AsBufferView(std::move(device_buffer)),
                      texture);
   blit_pass->GenerateMipmap(texture);
   EXPECT_TRUE(blit_pass->EncodeCommands());
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({command_buffer}).ok());
  
   auto image = DlImageImpeller::Make(texture);
  
   DisplayListBuilder builder;
   builder.DrawImageRect(
       image,
       DlRect::MakeWH(texture->GetSize().width, texture->GetSize().height),
       DlRect::MakeLTRB(0, 0, 100, 100), DlImageSampling::kMipmapLinear);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::DlImageImpeller::Make(), impeller::TextureDescriptor::mip_count, impeller::TSize< T >::MipCount(), impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [257/545]

impeller::testing::TEST_P	(	AiksTest	,
		MultipleTextWithShadowCache
	)

Definition at line 803 of file aiks_dl_text_unittests.cc.

                                               {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   AiksContext aiks_context(GetContext(),
                            std::make_shared<TypographerContextSkia>());
   // Cache empty
   EXPECT_EQ(aiks_context.GetContentContext()
                 .GetTextShadowCache()
                 .GetCacheSizeForTesting(),
             0u);
  
   for (auto i = 0; i < 5; i++) {
     ASSERT_TRUE(RenderTextInCanvasSkia(
         GetContext(), builder, "Hello World", kFontFixture,
         TextRenderOptions{
             .color = DlColor::kBlue(),
             .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)}));
   }
  
   DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
  
   // Text should be cached. Each text gets its own entry as we don't analyze the
   // strings.
   EXPECT_EQ(aiks_context.GetContentContext()
                 .GetTextShadowCache()
                 .GetCacheSizeForTesting(),
             5u);
 }

References impeller::testing::TextRenderOptions::color, impeller::DisplayListToTexture(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), impeller::ContentContext::GetTextShadowCache(), kFontFixture, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [258/545]

impeller::testing::TEST_P	(	AiksTest	,
		NoDimplesInRRectPath
	)

Definition at line 2034 of file aiks_dl_basic_unittests.cc.

                                        {
   Scalar width = 200.f;
   Scalar height = 60.f;
   Scalar corner = 1.f;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("width", &width, 0, 200);
       ImGui::SliderFloat("height", &height, 0, 200);
       ImGui::SliderFloat("corner", &corner, 0, 1);
       ImGui::End();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     DlPaint background_paint;
     background_paint.setColor(DlColor(1, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
     builder.DrawPaint(background_paint);
  
     std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue()};
     std::vector<Scalar> stops = {0.0, 1.0};
  
     DlPaint paint;
     auto gradient = DlColorSource::MakeLinear(DlPoint(0, 0), DlPoint(200, 200),
                                               2, colors.data(), stops.data(),
                                               DlTileMode::kClamp);
     paint.setColorSource(gradient);
     paint.setColor(DlColor::kWhite());
     paint.setDrawStyle(DlDrawStyle::kStroke);
     paint.setStrokeWidth(20);
  
     builder.Save();
     builder.Translate(100, 100);
  
     Scalar corner_x = ((1 - corner) * 50) + 50;
     Scalar corner_y = corner * 50 + 50;
     DlRoundRect rrect = DlRoundRect::MakeRectXY(
         DlRect::MakeXYWH(0, 0, width, height), corner_x, corner_y);
     builder.DrawRoundRect(rrect, paint);
     builder.Restore();
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), and x.

◆ TEST_P() [259/545]

impeller::testing::TEST_P	(	AiksTest	,
		NonSquareFilledArcsRenderCorrectly
	)

Definition at line 825 of file aiks_dl_basic_unittests.cc.

                                                      {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                     .vertical_scale = 0.8f,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [260/545]

impeller::testing::TEST_P	(	AiksTest	,
		NonSquareFilledArcsRenderCorrectlyWithCenter
	)

Definition at line 843 of file aiks_dl_basic_unittests.cc.

                                                                {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = true,
                     .full_circles = false,
                     .vertical_scale = 0.8f,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [261/545]

impeller::testing::TEST_P	(	AiksTest	,
		PaintBlendModeIsRespected
	)

Definition at line 172 of file aiks_dl_blend_unittests.cc.

                                             {
   DlPaint paint;
   DisplayListBuilder builder;
   // Default is kSourceOver.
  
   paint.setColor(DlColor::RGBA(1, 0, 0, 0.5));
   builder.DrawCircle(DlPoint(150, 200), 100, paint);
  
   paint.setColor(DlColor::RGBA(0, 1, 0, 0.5));
   builder.DrawCircle(DlPoint(250, 200), 100, paint);
  
   paint.setBlendMode(DlBlendMode::kPlus);
  
   paint.setColor(DlColor::kRed());
   builder.DrawCircle(DlPoint(450, 250), 100, paint);
  
   paint.setColor(DlColor::kGreen());
   builder.DrawCircle(DlPoint(550, 250), 100, paint);
  
   paint.setColor(DlColor::kBlue());
   builder.DrawCircle(DlPoint(500, 150), 100, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [262/545]

impeller::testing::TEST_P	(	AiksTest	,
		PipelineBlendSingleParameter
	)

Definition at line 1986 of file aiks_dl_basic_unittests.cc.

                                                {
   DisplayListBuilder builder;
  
   // Should render a green square in the middle of a blue circle.
   DlPaint paint;
   builder.SaveLayer(std::nullopt, &paint);
   {
     builder.Translate(100, 100);
     paint.setColor(DlColor::kBlue());
     builder.DrawCircle(DlPoint(200, 200), 200, paint);
     builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
  
     paint.setColor(DlColor::kGreen());
     paint.setBlendMode(DlBlendMode::kSrcOver);
     paint.setImageFilter(DlImageFilter::MakeColorFilter(
         DlColorFilter::MakeBlend(DlColor::kWhite(), DlBlendMode::kDst)));
     builder.DrawCircle(DlPoint(200, 200), 200, paint);
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [263/545]

impeller::testing::TEST_P	(	AiksTest	,
		ReleasesTextureOnTeardown
	)

Definition at line 594 of file aiks_dl_unittests.cc.

                                             {
   auto context = MakeContext();
   std::weak_ptr<Texture> weak_texture;
  
   {
     auto texture = CreateTextureForFixture("table_mountain_nx.png");
     weak_texture = texture;
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.Translate(100.0f, 100.0f);
  
     DlPaint paint;
     paint.setColorSource(DlColorSource::MakeImage(
         DlImageImpeller::Make(texture), DlTileMode::kClamp, DlTileMode::kClamp,
         DlImageSampling::kLinear, nullptr));
  
     builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
  
     ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
   }
  
   // See https://github.com/flutter/flutter/issues/134751.
   //
   // If the fence waiter was working this may not be released by the end of the
   // scope above. Adding a manual shutdown so that future changes to the fence
   // waiter will not flake this test.
   context->Shutdown();
  
   // The texture should be released by now.
   ASSERT_TRUE(weak_texture.expired()) << "When the texture is no longer in use "
                                          "by the backend, it should be "
                                          "released.";
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [264/545]

impeller::testing::TEST_P	(	AiksTest	,
		RotateColorFilteredPath
	)

Definition at line 27 of file aiks_dl_path_unittests.cc.

                                           {
   DisplayListBuilder builder;
   builder.Transform(DlMatrix::MakeTranslation(DlPoint(300, 300)) *
                     DlMatrix::MakeRotationZ(DlDegrees(90)));
  
   DlPathBuilder arrow_stem;
   DlPathBuilder arrow_head;
  
   arrow_stem.MoveTo(DlPoint(120, 190)).LineTo(DlPoint(120, 50));
   arrow_head.MoveTo(DlPoint(50, 120))
       .LineTo(DlPoint(120, 190))
       .LineTo(DlPoint(190, 120));
  
   auto filter =
       DlColorFilter::MakeBlend(DlColor::kAliceBlue(), DlBlendMode::kSrcIn);
  
   DlPaint paint;
   paint.setStrokeWidth(15.0);
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setStrokeJoin(DlStrokeJoin::kRound);
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setColorFilter(filter);
   paint.setColor(DlColor::kBlack());
  
   builder.DrawPath(arrow_stem.TakePath(), paint);
   builder.DrawPath(arrow_head.TakePath(), paint);
  
   auto dl = builder.Build();
   ASSERT_TRUE(OpenPlaygroundHere(dl));
 }

◆ TEST_P() [265/545]

impeller::testing::TEST_P	(	AiksTest	,
		RoundSuperellipseShadowComparison
	)

Definition at line 389 of file canvas_unittests.cc.

                                                     {
   // Config
   Size default_size(600, 400);
   Point left_center(400, 700);
   Point right_center(1300, 700);
   Color color = Color::Red();
  
   // Convert `color` to a `color_source`. This forces
   // `canvas.DrawRoundSuperellipse` to use the regular shadow algorithm
   // (blurring) instead of the fast shadow algorithm.
   std::shared_ptr<flutter::DlColorSource> color_source;
   {
     flutter::DlColor dl_color = flutter::DlColor(color.ToARGB());
     std::vector<flutter::DlColor> colors = {dl_color, dl_color};
     std::vector<Scalar> stops = {0.0, 1.0};
     color_source = flutter::DlColorSource::MakeLinear(
         {0, 0}, {1000, 1000}, 2, colors.data(), stops.data(),
         flutter::DlTileMode::kClamp);
   }
  
   auto RectMakeCenterHalfSize = [](Point center, Point half_size) {
     Size size(half_size.x * 2, half_size.y * 2);
     return Rect::MakeOriginSize(center - half_size, size);
   };
  
   RenderCallback callback = [&](RenderTarget& render_target) {
     ContentContext context(GetContext(), nullptr);
     Canvas canvas(context, render_target, true, false);
     // Somehow there's a scaling factor between PlaygroundPoint and Canvas.
     Matrix ctm = Matrix::MakeScale(Vector2(1, 1) * 0.5);
     Matrix i_ctm = ctm.Invert();
  
     static Scalar sigma = 0.05;
     static Scalar radius = 200;
  
     // Define the ImGui
     ImGui::Begin("Shadow", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
     {
       ImGui::SliderFloat("Sigma", &sigma, 0, 100);
       ImGui::SliderFloat("Radius", &radius, 0, 1000);
     }
     ImGui::End();
  
     static PlaygroundPoint right_reference_var(
         ctm * (right_center + default_size / 2), 30, Color::White());
     Point right_reference = i_ctm * DrawPlaygroundPoint(right_reference_var);
     Point half_size = (right_reference - right_center).Abs();
     Rect left_bounds = RectMakeCenterHalfSize(left_center, half_size);
     Rect right_bounds = RectMakeCenterHalfSize(right_center, half_size);
  
     Paint paint{
         .color = color,
         .mask_blur_descriptor =
             Paint::MaskBlurDescriptor{
                 .sigma = Sigma(sigma),
             },
     };
  
     // Left: Draw with canvas
     canvas.DrawRoundSuperellipse(
         RoundSuperellipse::MakeRectRadius(left_bounds, radius), paint);
  
     // Right: Direct draw
     paint.color_source = color_source.get();
     canvas.DrawRoundSuperellipse(
         RoundSuperellipse::MakeRectRadius(right_bounds, radius), paint);
  
     canvas.EndReplay();
     return true;
   };
  
   ASSERT_TRUE(Playground::OpenPlaygroundHere(callback));
 }

References impeller::Paint::color, impeller::DrawPlaygroundPoint(), impeller::Canvas::DrawRoundSuperellipse(), impeller::Canvas::EndReplay(), impeller::Matrix::Invert(), impeller::TRect< Scalar >::MakeOriginSize(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::Matrix::MakeScale(), impeller::Playground::OpenPlaygroundHere(), impeller::Color::Red(), impeller::Paint::MaskBlurDescriptor::sigma, impeller::Color::ToARGB(), and impeller::Color::White().

◆ TEST_P() [266/545]

impeller::testing::TEST_P	(	AiksTest	,
		RuntimeEffectWithInvalidSamplerDoesNotCrash
	)

Definition at line 111 of file aiks_dl_runtime_effect_unittests.cc.

                                                               {
   ScopedValidationDisable disable_validation;
  
   // Create a sampler that is not usable as an input to the runtime effect.
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                           flutter::DlColor::kRed()};
   const float stops[2] = {0.0, 1.0};
   auto linear = flutter::DlColorSource::MakeLinear({0.0, 0.0}, {300.0, 300.0},
                                                    2, colors.data(), stops,
                                                    flutter::DlTileMode::kClamp);
   std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
       linear,
   };
  
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(Vector2));
  
   DlPaint paint;
   paint.setColorSource(
       MakeRuntimeEffect(this, "runtime_stage_filter_example.frag.iplr",
                         uniform_data, sampler_inputs));
  
   DisplayListBuilder builder;
   builder.DrawPaint(paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [267/545]

impeller::testing::TEST_P	(	AiksTest	,
		SaveLayerDrawsBehindSubsequentEntities
	)

Definition at line 1841 of file aiks_dl_basic_unittests.cc.

                                                          {
   // Compare with https://fiddle.skia.org/c/9e03de8567ffb49e7e83f53b64bcf636
   DisplayListBuilder builder;
   DlPaint paint;
  
   paint.setColor(DlColor::kBlack());
   DlRect rect = DlRect::MakeXYWH(25, 25, 25, 25);
   builder.DrawRect(rect, paint);
  
   builder.Translate(10, 10);
  
   DlPaint save_paint;
   builder.SaveLayer(std::nullopt, &save_paint);
  
   paint.setColor(DlColor::kGreen());
   builder.DrawRect(rect, paint);
  
   builder.Restore();
  
   builder.Translate(10, 10);
   paint.setColor(DlColor::kRed());
   builder.DrawRect(rect, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [268/545]

impeller::testing::TEST_P	(	AiksTest	,
		SaveLayerFiltersScaleWithTransform
	)

Definition at line 1933 of file aiks_dl_basic_unittests.cc.

                                                      {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.Translate(100, 100);
  
   auto texture = DlImageImpeller::Make(CreateTextureForFixture("boston.jpg"));
   auto draw_image_layer = [&builder, &texture](const DlPaint& paint) {
     builder.SaveLayer(std::nullopt, &paint);
     builder.DrawImage(texture, DlPoint(), DlImageSampling::kLinear);
     builder.Restore();
   };
  
   DlPaint effect_paint;
   effect_paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 6));
   draw_image_layer(effect_paint);
  
   builder.Translate(300, 300);
   builder.Scale(3, 3);
   draw_image_layer(effect_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [269/545]

impeller::testing::TEST_P	(	AiksTest	,
		ScaledK
	)

Definition at line 173 of file aiks_dl_text_unittests.cc.

                           {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
   for (int i = 0; i < 6; ++i) {
     builder.Save();
     builder.Translate(300 * i, 0);
     Scalar scale = 0.445 - (i / 1000.f);
     builder.Scale(scale, scale);
     RenderTextInCanvasSkia(
         GetContext(), builder, "k", "Roboto-Regular.ttf",
         TextRenderOptions{.font_size = 600, .position = DlPoint(10, 500)});
     RenderTextInCanvasSkia(
         GetContext(), builder, "k", "Roboto-Regular.ttf",
         TextRenderOptions{.font_size = 300, .position = DlPoint(10, 800)});
     builder.Restore();
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::testing::TextRenderOptions::font_size, and RenderTextInCanvasSkia().

◆ TEST_P() [270/545]

impeller::testing::TEST_P	(	AiksTest	,
		ScaleExperimentAntialiasLines
	)

Definition at line 628 of file aiks_dl_path_unittests.cc.

                                                 {
   Scalar scale = 5.0;
   Scalar line_width = 10.f;
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("Scale", &scale, 0.001, 5);
       ImGui::SliderFloat("Width", &line_width, 1, 20);
  
       ImGui::End();
     }
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     builder.DrawPaint(DlPaint(DlColor(0xff111111)));
  
     {
       DlPaint paint;
       paint.setColor(DlColor::kGreenYellow());
       paint.setStrokeWidth(line_width);
  
       builder.DrawLine(DlPoint(100, 100), DlPoint(350, 100), paint);
       builder.DrawLine(DlPoint(100, 100), DlPoint(350, 150), paint);
  
       builder.Save();
       builder.Translate(100, 300);
       builder.Scale(scale, scale);
       builder.Translate(-100, -300);
       builder.DrawLine(DlPoint(100, 300), DlPoint(350, 300), paint);
       builder.DrawLine(DlPoint(100, 300), DlPoint(350, 450), paint);
       builder.Restore();
     }
  
     {
       DlPaint paint;
       paint.setColor(DlColor::kGreenYellow());
       paint.setStrokeWidth(2.0);
  
       builder.Save();
       builder.Translate(100, 500);
       builder.Scale(0.2, 0.2);
       builder.Translate(-100, -500);
       builder.DrawLine(DlPoint(100, 500), DlPoint(350, 500), paint);
       builder.DrawLine(DlPoint(100, 500), DlPoint(350, 650), paint);
       builder.Restore();
     }
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::AiksPlayground::ImGuiBegin(), and x.

◆ TEST_P() [271/545]

impeller::testing::TEST_P	(	AiksTest	,
		SetContentsWithRegion
	)

Definition at line 560 of file aiks_dl_unittests.cc.

                                         {
   auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  
   // Replace part of the texture with a red rectangle.
   std::vector<uint8_t> bytes(100 * 100 * 4);
   for (auto i = 0u; i < bytes.size(); i += 4) {
     bytes[i] = 255;
     bytes[i + 1] = 0;
     bytes[i + 2] = 0;
     bytes[i + 3] = 255;
   }
   auto mapping =
       std::make_shared<fml::NonOwnedMapping>(bytes.data(), bytes.size());
   auto device_buffer =
       GetContext()->GetResourceAllocator()->CreateBufferWithCopy(*mapping);
   auto cmd_buffer = GetContext()->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
   blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer), bridge,
                      IRect::MakeLTRB(50, 50, 150, 150));
  
   auto did_submit =
       blit_pass->EncodeCommands() &&
       GetContext()->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok();
   ASSERT_TRUE(did_submit);
  
   auto image = DlImageImpeller::Make(bridge);
  
   DisplayListBuilder builder;
   builder.DrawImage(image, DlPoint(0, 0), {});
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::DlImageImpeller::Make(), and impeller::TRect< T >::MakeLTRB().

◆ TEST_P() [272/545]

impeller::testing::TEST_P	(	AiksTest	,
		SiblingSaveLayerBoundsAreRespected
	)

Definition at line 1867 of file aiks_dl_basic_unittests.cc.

                                                      {
   DisplayListBuilder builder;
   DlPaint paint;
   DlRect rect = DlRect::MakeXYWH(0, 0, 1000, 1000);
  
   // Black, green, and red squares offset by [10, 10].
   {
     DlPaint save_paint;
     DlRect bounds = DlRect::MakeXYWH(25, 25, 25, 25);
     builder.SaveLayer(bounds, &save_paint);
     paint.setColor(DlColor::kBlack());
     builder.DrawRect(rect, paint);
     builder.Restore();
   }
  
   {
     DlPaint save_paint;
     DlRect bounds = DlRect::MakeXYWH(35, 35, 25, 25);
     builder.SaveLayer(bounds, &save_paint);
     paint.setColor(DlColor::kGreen());
     builder.DrawRect(rect, paint);
     builder.Restore();
   }
  
   {
     DlPaint save_paint;
     DlRect bounds = DlRect::MakeXYWH(45, 45, 25, 25);
     builder.SaveLayer(bounds, &save_paint);
     paint.setColor(DlColor::kRed());
     builder.DrawRect(rect, paint);
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [273/545]

impeller::testing::TEST_P	(	AiksTest	,
		SimpleExperimentAntialiasLines
	)

Definition at line 743 of file aiks_dl_path_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   builder.DrawPaint(DlPaint(DlColor(0xff111111)));
  
   DlPaint paint;
   paint.setColor(DlColor::kGreenYellow());
   paint.setStrokeWidth(10);
  
   auto draw = [&builder](DlPaint& paint) {
     for (auto cap :
          {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
       paint.setStrokeCap(cap);
       DlPoint origin = {100, 100};
       builder.DrawLine(DlPoint(150, 100), DlPoint(250, 100), paint);
       for (int d = 15; d < 90; d += 15) {
         Matrix m = Matrix::MakeRotationZ(Degrees(d));
         Point origin = {100, 100};
         Point p0 = {50, 0};
         Point p1 = {150, 0};
         auto a = origin + m * p0;
         auto b = origin + m * p1;
  
         builder.DrawLine(a, b, paint);
       }
       builder.DrawLine(DlPoint(100, 150), DlPoint(100, 250), paint);
       builder.DrawCircle(origin, 35, paint);
  
       builder.DrawLine(DlPoint(250, 250), DlPoint(250, 250), paint);
  
       builder.Translate(250, 0);
     }
     builder.Translate(-750, 250);
   };
  
   draw(paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::saturated::b, impeller::Matrix::MakeRotationZ(), and x.

◆ TEST_P() [274/545]

impeller::testing::TEST_P	(	AiksTest	,
		SingleIconShadowTest
	)

Definition at line 836 of file aiks_dl_text_unittests.cc.

                                        {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   AiksContext aiks_context(GetContext(),
                            std::make_shared<TypographerContextSkia>());
   // Cache empty
   EXPECT_EQ(aiks_context.GetContentContext()
                 .GetTextShadowCache()
                 .GetCacheSizeForTesting(),
             0u);
  
   // Create font instance outside loop so all draws use identical font instance.
   auto c_font_fixture = std::string(kFontFixture);
   auto mapping = flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
   ASSERT_TRUE(mapping);
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   SkFont sk_font(font_mgr->makeFromData(mapping), 50);
  
   for (auto i = 0; i < 10; i++) {
     ASSERT_TRUE(RenderTextInCanvasSkia(
         GetContext(), builder, "A", kFontFixture,
         TextRenderOptions{
             .color = DlColor::kBlue(),
             .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)},
         sk_font));
   }
  
   DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
  
   // Text should be cached. All 10 glyphs use the same cache entry.
   EXPECT_EQ(aiks_context.GetContentContext()
                 .GetTextShadowCache()
                 .GetCacheSizeForTesting(),
             1u);
 }

References impeller::testing::TextRenderOptions::color, impeller::DisplayListToTexture(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), impeller::ContentContext::GetTextShadowCache(), kFontFixture, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [275/545]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorCircleMaskBlurTinySigma
	)

Definition at line 128 of file aiks_dl_blur_unittests.cc.

                                                     {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   std::vector<float> sigmas = {0.0, 0.01, 1.0};
   std::vector<DlColor> colors = {DlColor::kGreen(), DlColor::kYellow(),
                                  DlColor::kRed()};
   for (uint32_t i = 0; i < sigmas.size(); ++i) {
     DlPaint paint;
     paint.setColor(colors[i]);
     paint.setMaskFilter(
         DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigmas[i]));
  
     builder.Save();
     builder.Translate(100 + (i * 100), 100);
     DlRoundRect rrect = DlRoundRect::MakeRectXY(
         DlRect::MakeXYWH(0, 0, 100.0f, 100.0f), 100, 100);
     builder.DrawRoundRect(rrect, paint);
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [276/545]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorCirclesOvalsRRectsMaskBlurCorrectly
	)

Definition at line 1203 of file aiks_dl_basic_unittests.cc.

                                                                 {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1.0f));
  
   builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
  
   paint.setColor(
       DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f));
   Scalar y = 100.0f;
   for (int i = 0; i < 5; i++) {
     Scalar x = (i + 1) * 100;
     Scalar radius = x / 10.0f;
     builder.DrawRect(DlRect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                       radius, 60.0f - radius),
                      paint);
   }
  
   paint.setColor(DlColor::kBlue());
   y += 100.0f;
   for (int i = 0; i < 5; i++) {
     Scalar x = (i + 1) * 100;
     Scalar radius = x / 10.0f;
     builder.DrawCircle(DlPoint(x + 25, y + 25), radius, paint);
   }
  
   paint.setColor(DlColor::kGreen());
   y += 100.0f;
   for (int i = 0; i < 5; i++) {
     Scalar x = (i + 1) * 100;
     Scalar radius = x / 10.0f;
     builder.DrawOval(DlRect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                       radius, 60.0f - radius),
                      paint);
   }
  
   paint.setColor(
       DlColor::RGBA(128.0f / 255.0f, 0.0f / 255.0f, 128.0f / 255.0f, 1.0f));
   y += 100.0f;
   for (int i = 0; i < 5; i++) {
     Scalar x = (i + 1) * 100;
     Scalar radius = x / 20.0f;
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                                 radius, radius),
         paint);
   }
  
   paint.setColor(
       DlColor::RGBA(255.0f / 255.0f, 165.0f / 255.0f, 0.0f / 255.0f, 1.0f));
   y += 100.0f;
   for (int i = 0; i < 5; i++) {
     Scalar x = (i + 1) * 100;
     Scalar radius = x / 20.0f;
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                                 radius, 5.0f),
         paint);
   }
  
   auto dl = builder.Build();
   ASSERT_TRUE(OpenPlaygroundHere(dl));
 }

References x.

◆ TEST_P() [277/545]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorOvalsMaskBlurTinySigma
	)

Definition at line 38 of file aiks_dl_blur_unittests.cc.

                                                    {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   std::vector<float> sigmas = {0.0, 0.01, 1.0};
   std::vector<DlColor> colors = {DlColor::kGreen(), DlColor::kYellow(),
                                  DlColor::kRed()};
   for (uint32_t i = 0; i < sigmas.size(); ++i) {
     DlPaint paint;
     paint.setColor(colors[i]);
     paint.setMaskFilter(
         DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigmas[i]));
  
     builder.Save();
     builder.Translate(100 + (i * 100), 100);
     DlRoundRect rrect =
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 60.0f, 160.0f), 50, 100);
     builder.DrawRoundRect(rrect, paint);
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [278/545]

impeller::testing::TEST_P	(	AiksTest	,
		SolidStrokesRenderCorrectly
	)

Definition at line 473 of file aiks_dl_path_unittests.cc.

                                               {
   // Compare with https://fiddle.skia.org/c/027392122bec8ac2b5d5de00a4b9bbe2
   auto callback = [&]() -> sk_sp<DisplayList> {
     static Color color = Color::Black().WithAlpha(0.5);
     static float scale = 3;
     static bool add_circle_clip = true;
  
     if (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();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     DlPaint paint;
  
     paint.setColor(DlColor::kWhite());
     builder.DrawPaint(paint);
  
     paint.setColor(
         DlColor::ARGB(color.alpha, color.red, color.green, color.blue));
     paint.setDrawStyle(DlDrawStyle::kStroke);
     paint.setStrokeWidth(10);
  
     DlPathBuilder path_builder;
     path_builder.MoveTo(DlPoint(20, 20));
     path_builder.QuadraticCurveTo(DlPoint(60, 20), DlPoint(60, 60));
     path_builder.Close();
     path_builder.MoveTo(DlPoint(60, 20));
     path_builder.QuadraticCurveTo(DlPoint(60, 60), DlPoint(20, 60));
     DlPath path = path_builder.TakePath();
  
     builder.Scale(scale, scale);
  
     if (add_circle_clip) {
       static PlaygroundPoint circle_clip_point_a(Point(60, 300), 20,
                                                  Color::Red());
       static PlaygroundPoint circle_clip_point_b(Point(600, 300), 20,
                                                  Color::Red());
       auto [handle_a, handle_b] =
           DrawPlaygroundLine(circle_clip_point_a, circle_clip_point_b);
  
       Matrix screen_to_canvas = builder.GetMatrix();
       if (!screen_to_canvas.IsInvertible()) {
         return nullptr;
       }
       screen_to_canvas = screen_to_canvas.Invert();
  
       Point point_a = screen_to_canvas * handle_a;
       Point point_b = screen_to_canvas * handle_b;
  
       Point middle = point_a + point_b;
       middle *= GetContentScale().x / 2;
  
       auto radius = point_a.GetDistance(middle);
  
       builder.ClipPath(DlPath::MakeCircle(middle, radius));
     }
  
     for (auto join :
          {DlStrokeJoin::kBevel, DlStrokeJoin::kRound, DlStrokeJoin::kMiter}) {
       paint.setStrokeJoin(join);
       for (auto cap :
            {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
         paint.setStrokeCap(cap);
         builder.DrawPath(path, paint);
         builder.Translate(80, 0);
       }
       builder.Translate(-240, 60);
     }
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::alpha, impeller::Color::Black(), impeller::Color::blue, impeller::DrawPlaygroundLine(), impeller::TPoint< T >::GetDistance(), impeller::Color::green, impeller::AiksPlayground::ImGuiBegin(), impeller::Matrix::Invert(), impeller::Matrix::IsInvertible(), impeller::Color::red, impeller::Color::Red(), impeller::Color::WithAlpha(), x, and impeller::TPoint< T >::x.

◆ TEST_P() [279/545]

impeller::testing::TEST_P	(	AiksTest	,
		SrgbToLinearFilterSubpassCollapseOptimization
	)

Definition at line 122 of file aiks_dl_unittests.cc.

                                                                 {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColorFilter(DlColorFilter::MakeLinearToSrgbGamma());
   builder.SaveLayer(std::nullopt, &paint);
  
   builder.Translate(500, 300);
   builder.Rotate(120);  // 120 deg
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), draw_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [280/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokeCapsAndJoins
	)

Definition at line 987 of file aiks_dl_path_unittests.cc.

                                      {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   builder.Translate(100, 0);
  
   builder.Save();
   for (auto cap : std::vector<DlStrokeCap>{
            DlStrokeCap::kButt, DlStrokeCap::kRound, DlStrokeCap::kSquare}) {
     DlPathBuilder path_builder;
     path_builder.MoveTo({20, 50});
     path_builder.LineTo({50, 50});
     path_builder.MoveTo({120, 50});
     path_builder.LineTo({120, 80});
     path_builder.MoveTo({180, 50});
     path_builder.LineTo({180, 50});
     DlPath path = path_builder.TakePath();
  
     DlPaint paint;
     paint.setColor(DlColor::kRed());
     paint.setDrawStyle(DlDrawStyle::kStroke);
     paint.setStrokeWidth(20.0f);
     paint.setStrokeCap(cap);
     paint.setStrokeJoin(DlStrokeJoin::kBevel);
  
     builder.DrawPath(path, paint);
  
     paint.setColor(DlColor::kYellow());
     paint.setStrokeWidth(1.0f);
     paint.setStrokeCap(DlStrokeCap::kButt);
  
     builder.DrawPath(path, paint);
  
     builder.Translate(250, 0);
   }
   builder.Restore();
  
   builder.Translate(0, 100);
  
   builder.Save();
   for (auto join : std::vector<DlStrokeJoin>{
            DlStrokeJoin::kBevel, DlStrokeJoin::kRound, DlStrokeJoin::kMiter}) {
     DlPathBuilder path_builder;
     path_builder.MoveTo({20, 50});  // 0 degree right turn
     path_builder.LineTo({50, 50});
     path_builder.LineTo({80, 50});
     path_builder.MoveTo({20, 150});  // 90 degree right turn
     path_builder.LineTo({50, 150});
     path_builder.LineTo({50, 180});
     path_builder.MoveTo({20, 250});  // 45 degree right turn
     path_builder.LineTo({50, 250});
     path_builder.LineTo({70, 270});
     path_builder.MoveTo({20, 350});  // 135 degree right turn
     path_builder.LineTo({50, 350});
     path_builder.LineTo({30, 370});
     path_builder.MoveTo({20, 450});  // 180 degree right turn
     path_builder.LineTo({50, 450});
     path_builder.LineTo({20, 450});
     path_builder.MoveTo({120, 80});  // 0 degree left turn
     path_builder.LineTo({150, 80});
     path_builder.LineTo({180, 80});
     path_builder.MoveTo({120, 180});  // 90 degree left turn
     path_builder.LineTo({150, 180});
     path_builder.LineTo({150, 150});
     path_builder.MoveTo({120, 280});  // 45 degree left turn
     path_builder.LineTo({150, 280});
     path_builder.LineTo({170, 260});
     path_builder.MoveTo({120, 380});  // 135 degree left turn
     path_builder.LineTo({150, 380});
     path_builder.LineTo({130, 360});
     path_builder.MoveTo({120, 480});  // 180 degree left turn
     path_builder.LineTo({150, 480});
     path_builder.LineTo({120, 480});
     DlPath path = path_builder.TakePath();
  
     DlPaint paint;
  
     paint.setColor(DlColor::kRed());
     paint.setDrawStyle(DlDrawStyle::kStroke);
     paint.setStrokeWidth(20.0f);
     paint.setStrokeCap(DlStrokeCap::kSquare);
     paint.setStrokeJoin(join);
     builder.DrawPath(path, paint);
  
     paint.setColor(DlColor::kYellow());
     paint.setStrokeWidth(1.0f);
     paint.setStrokeCap(DlStrokeCap::kButt);
     builder.DrawPath(path, paint);
  
     builder.Translate(250, 0);
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [281/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsCoverFullArcWithButtEnds
	)

Definition at line 1054 of file aiks_dl_basic_unittests.cc.

                                                       {
   // This test compares the rendering of a full circle arc against a partial
   // arc by drawing a one over the other in high contrast. If the partial
   // arc misses any pixels that were drawn by the full arc, there will be
   // some "pixel dirt" around the missing "erased" parts of the arcs. This
   // case arises while rendering a CircularProgressIndicator with a background
   // color where we want the rendering of the background full arc to hit the
   // same pixels around the edges as the partial arc that covers it.
   //
   // In this case we draw a full blue circle and then draw a partial arc
   // over it in the background color (white).
  
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeCap(DlStrokeCap::kButt);
   paint.setColor(DlColor::kBlue());
  
   // First draw full circles in blue to establish the pixels to be erased
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = true,
                 });
  
   paint.setColor(DlColor::kWhite());
  
   // Then draw partial arcs in white over the circles to "erase" them
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [282/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithBevelJoinsAndCenter
	)

Definition at line 921 of file aiks_dl_basic_unittests.cc.

                                                                     {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeJoin(DlStrokeJoin::kBevel);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = true,
                     .full_circles = false,
                     .sweeps_over_360 = true,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [283/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithButtEnds
	)

Definition at line 861 of file aiks_dl_basic_unittests.cc.

                                                          {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeCap(DlStrokeCap::kButt);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [284/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithMiterJoinsAndCenter
	)

Definition at line 942 of file aiks_dl_basic_unittests.cc.

                                                                     {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeJoin(DlStrokeJoin::kMiter);
   // Default miter of 4.0 does a miter on all of the centers, but
   // using 3.0 will show some bevels on the widest interior angles...
   paint.setStrokeMiter(3.0f);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = true,
                     .full_circles = false,
                     .sweeps_over_360 = true,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [285/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithRoundEnds
	)

Definition at line 901 of file aiks_dl_basic_unittests.cc.

                                                           {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [286/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithRoundJoinsAndCenter
	)

Definition at line 966 of file aiks_dl_basic_unittests.cc.

                                                                     {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeJoin(DlStrokeJoin::kRound);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = true,
                     .full_circles = false,
                     .sweeps_over_360 = true,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [287/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithSquareAndButtAndRoundEnds
	)

Definition at line 1016 of file aiks_dl_basic_unittests.cc.

                                                                           {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(8.0f);
   paint.setStrokeCap(DlStrokeCap::kSquare);
   paint.setColor(DlColor::kRed());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setColor(DlColor::kGreen());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   paint.setStrokeCap(DlStrokeCap::kButt);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [288/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithSquareAndButtEnds
	)

Definition at line 987 of file aiks_dl_basic_unittests.cc.

                                                                   {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(8.0f);
   paint.setStrokeCap(DlStrokeCap::kSquare);
   paint.setColor(DlColor::kRed());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   paint.setStrokeCap(DlStrokeCap::kButt);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [289/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithSquareEnds
	)

Definition at line 881 of file aiks_dl_basic_unittests.cc.

                                                            {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(6.0f);
   paint.setStrokeCap(DlStrokeCap::kSquare);
   paint.setColor(DlColor::kBlue());
  
   RenderArcFarm(builder, paint,
                 {
                     .use_center = false,
                     .full_circles = false,
                 });
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References x.

◆ TEST_P() [290/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedCirclesRenderCorrectly
	)

Definition at line 623 of file aiks_dl_basic_unittests.cc.

                                                 {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   const int color_count = 3;
   DlColor colors[color_count] = {
       DlColor::kBlue(),
       DlColor::kGreen(),
       DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
   };
  
   paint.setColor(DlColor::kWhite());
   builder.DrawPaint(paint);
  
   int c_index = 0;
  
   auto draw = [&paint, &colors, &c_index](DlCanvas& canvas, DlPoint center,
                                           Scalar r, Scalar dr, int n) {
     for (int i = 0; i < n; i++) {
       paint.setColor(colors[(c_index++) % color_count]);
       canvas.DrawCircle(center, r, paint);
       r += dr;
     }
   };
  
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(1);
   draw(builder, DlPoint(10, 10), 2, 2, 14);  // r = [2, 28], covers [1,29]
   paint.setStrokeWidth(5);
   draw(builder, DlPoint(10, 10), 35, 10, 56);  // r = [35, 585], covers [30,590]
  
   DlColor gradient_colors[7] = {
       DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
       DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
       DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
       DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
   };
   DlScalar stops[7] = {
       0.0,
       (1.0 / 6.0) * 1,
       (1.0 / 6.0) * 2,
       (1.0 / 6.0) * 3,
       (1.0 / 6.0) * 4,
       (1.0 / 6.0) * 5,
       1.0,
   };
   auto texture = CreateTextureForFixture("airplane.jpg",
                                          /*enable_mipmapping=*/true);
   auto image = DlImageImpeller::Make(texture);
  
   paint.setColorSource(DlColorSource::MakeRadial(
       DlPoint(500, 600), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
   draw(builder, DlPoint(500, 600), 5, 10, 10);
  
   DlMatrix local_matrix = DlMatrix::MakeTranslation({700, 200});
   paint.setColorSource(DlColorSource::MakeImage(
       image, DlTileMode::kRepeat, DlTileMode::kRepeat,
       DlImageSampling::kNearestNeighbor, &local_matrix));
   draw(builder, DlPoint(800, 300), 5, 10, 10);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make(), and x.

◆ TEST_P() [291/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedPathWithMoveToThenCloseDrawnCorrectly
	)

Definition at line 536 of file aiks_dl_unittests.cc.

                                                                {
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(0, 400))
       .LineTo(DlPoint(0, 0))
       .LineTo(DlPoint(400, 0))
       // MoveTo implicitly adds a contour, ensure that close doesn't
       // add another nearly-empty contour.
       .MoveTo(DlPoint(0, 400))
       .Close();
   DlPath path = path_builder.TakePath();
  
   DisplayListBuilder builder;
   builder.Translate(50, 50);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   paint.setStrokeCap(DlStrokeCap::kRound);
   paint.setStrokeWidth(10);
   paint.setDrawStyle(DlDrawStyle::kStroke);
   builder.DrawPath(path, paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [292/545]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedRectsRenderCorrectly
	)

Definition at line 427 of file aiks_dl_basic_unittests.cc.

                                               {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   DlPaint paint;
   paint.setColor(DlColor::kPurple());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(20.0f);
  
   DlPaint thin_paint = paint;
   thin_paint.setColor(DlColor::kYellow());
   thin_paint.setStrokeWidth(0.0f);
  
   DlRect rect = DlRect::MakeLTRB(10, 10, 90, 90);
   DlRect thin_tall_rect = DlRect::MakeLTRB(120, 10, 120, 90);
   DlRect thin_wide_rect = DlRect::MakeLTRB(10, 120, 90, 120);
   DlRect empty_rect = DlRect::MakeLTRB(120, 120, 120, 120);
  
   // We draw the following sets of rectangles:
   //
   //      A     E     X
   //                  X
   //      B     F     X
   //                  X
   //      C  D  G  H  X
   //
   // Purple A,B,C,D are all drawn with stroke width 20 (non-overflowing).
   // Each of those sets has 4 rectangles of dimension 80x80, 80x0, 0x80,
   // and 0,0 to demonstrate the basic behavior and also the behavior of
   // empty dimensions.
   //
   // Blue E,F,G,H are the same 80x80 rectangles, but with an overflowing
   // stroke width of 120 to show the behavior with degenerately large
   // stroke widths.
   //
   // A,E are drawn with Bevel joins.
   // B,F are drawn with Round joins.
   // C,G are drawn with Miter joins and a large enough miter limit.
   // D,H are drawn with Miter joins and a too small miter limit (== Bevel).
   //
   // All orange X rectangles are drawn with round joins and increasing stroke
   // widths to demonstrate fidelity of the rounding code at various arc sizes.
   // These X rectangles also help test that the variable sizing estimates in
   // the round join code are accurate.
  
   // rects (A)
   paint.setStrokeJoin(DlStrokeJoin::kBevel);
   builder.DrawRect(rect.Shift({100, 100}), paint);
   builder.DrawRect(rect.Shift({100, 100}), thin_paint);
   builder.DrawRect(thin_tall_rect.Shift({100, 100}), paint);
   builder.DrawRect(thin_tall_rect.Shift({100, 100}), thin_paint);
   builder.DrawRect(thin_wide_rect.Shift({100, 100}), paint);
   builder.DrawRect(thin_wide_rect.Shift({100, 100}), thin_paint);
   builder.DrawRect(empty_rect.Shift({100, 100}), paint);
   builder.DrawRect(empty_rect.Shift({100, 100}), thin_paint);
  
   // rects (B)
   paint.setStrokeJoin(DlStrokeJoin::kRound);
   builder.DrawRect(rect.Shift({100, 300}), paint);
   builder.DrawRect(rect.Shift({100, 300}), thin_paint);
   builder.DrawRect(thin_tall_rect.Shift({100, 300}), paint);
   builder.DrawRect(thin_tall_rect.Shift({100, 300}), thin_paint);
   builder.DrawRect(thin_wide_rect.Shift({100, 300}), paint);
   builder.DrawRect(thin_wide_rect.Shift({100, 300}), thin_paint);
   builder.DrawRect(empty_rect.Shift({100, 300}), paint);
   builder.DrawRect(empty_rect.Shift({100, 300}), thin_paint);
  
   // rects (C)
   paint.setStrokeJoin(DlStrokeJoin::kMiter);
   paint.setStrokeMiter(kSqrt2 + flutter::kEhCloseEnough);
   builder.DrawRect(rect.Shift({100, 500}), paint);
   builder.DrawRect(rect.Shift({100, 500}), thin_paint);
   builder.DrawRect(thin_tall_rect.Shift({100, 500}), paint);
   builder.DrawRect(thin_tall_rect.Shift({100, 500}), thin_paint);
   builder.DrawRect(thin_wide_rect.Shift({100, 500}), paint);
   builder.DrawRect(thin_wide_rect.Shift({100, 500}), thin_paint);
   builder.DrawRect(empty_rect.Shift({100, 500}), paint);
   builder.DrawRect(empty_rect.Shift({100, 500}), thin_paint);
  
   // rects (D)
   paint.setStrokeJoin(DlStrokeJoin::kMiter);
   paint.setStrokeMiter(kSqrt2 - flutter::kEhCloseEnough);
   builder.DrawRect(rect.Shift({300, 500}), paint);
   builder.DrawRect(rect.Shift({300, 500}), thin_paint);
   builder.DrawRect(thin_tall_rect.Shift({300, 500}), paint);
   builder.DrawRect(thin_tall_rect.Shift({300, 500}), thin_paint);
   builder.DrawRect(thin_wide_rect.Shift({300, 500}), paint);
   builder.DrawRect(thin_wide_rect.Shift({300, 500}), thin_paint);
   builder.DrawRect(empty_rect.Shift({300, 500}), paint);
   builder.DrawRect(empty_rect.Shift({300, 500}), thin_paint);
  
   paint.setStrokeWidth(120.0f);
   paint.setColor(DlColor::kBlue());
   rect = rect.Expand(-20);
  
   // rect (E)
   paint.setStrokeJoin(DlStrokeJoin::kBevel);
   builder.DrawRect(rect.Shift({500, 100}), paint);
   builder.DrawRect(rect.Shift({500, 100}), thin_paint);
  
   // rect (F)
   paint.setStrokeJoin(DlStrokeJoin::kRound);
   builder.DrawRect(rect.Shift({500, 300}), paint);
   builder.DrawRect(rect.Shift({500, 300}), thin_paint);
  
   // rect (G)
   paint.setStrokeJoin(DlStrokeJoin::kMiter);
   paint.setStrokeMiter(kSqrt2 + flutter::kEhCloseEnough);
   builder.DrawRect(rect.Shift({500, 500}), paint);
   builder.DrawRect(rect.Shift({500, 500}), thin_paint);
  
   // rect (H)
   paint.setStrokeJoin(DlStrokeJoin::kMiter);
   paint.setStrokeMiter(kSqrt2 - flutter::kEhCloseEnough);
   builder.DrawRect(rect.Shift({700, 500}), paint);
   builder.DrawRect(rect.Shift({700, 500}), thin_paint);
  
   DlPaint round_mock_paint;
   round_mock_paint.setColor(DlColor::kGreen());
   round_mock_paint.setDrawStyle(DlDrawStyle::kFill);
  
   // array of rects (X)
   Scalar x = 900;
   Scalar y = 50;
   for (int i = 0; i < 15; i++) {
     paint.setStrokeWidth(i);
     paint.setColor(DlColor::kOrange());
     paint.setStrokeJoin(DlStrokeJoin::kRound);
     builder.DrawRect(DlRect::MakeXYWH(x, y, 30, 30), paint);
     y += 32 + i;
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::kEhCloseEnough, impeller::kSqrt2, and x.

◆ TEST_P() [293/545]

impeller::testing::TEST_P	(	AiksTest	,
		SubpassWithClearColorOptimization
	)

Definition at line 1441 of file aiks_dl_basic_unittests.cc.

                                                     {
   DisplayListBuilder builder;
  
   // Use a non-srcOver blend mode to ensure that we don't detect this as an
   // opacity peephole optimization.
   DlPaint paint;
   paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
   paint.setBlendMode(DlBlendMode::kSrc);
  
   DlRect bounds = DlRect::MakeLTRB(0, 0, 200, 200);
   builder.SaveLayer(bounds, &paint);
  
   paint.setColor(DlColor::kTransparent());
   paint.setBlendMode(DlBlendMode::kSrc);
   builder.DrawPaint(paint);
   builder.Restore();
  
   paint.setColor(DlColor::kBlue());
   paint.setBlendMode(DlBlendMode::kDstOver);
   builder.SaveLayer(std::nullopt, &paint);
   builder.Restore();
  
   // This playground should appear blank on CI since we are only drawing
   // transparent black. If the clear color optimization is broken, the texture
   // will be filled with NaNs and may produce a magenta texture on macOS or iOS.
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [294/545]

impeller::testing::TEST_P	(	AiksTest	,
		SupportsBlitToOnscreen
	)

Definition at line 377 of file canvas_unittests.cc.

                                          {
   ContentContext context(GetContext(), nullptr);
   auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                  /*requires_readback=*/true);
  
   if (GetBackend() != PlaygroundBackend::kMetal) {
     EXPECT_FALSE(canvas->SupportsBlitToOnscreen());
   } else {
     EXPECT_TRUE(canvas->SupportsBlitToOnscreen());
   }
 }

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

◆ TEST_P() [295/545]

impeller::testing::TEST_P	(	AiksTest	,
		TextContentsMismatchedTransformTest
	)

Definition at line 707 of file aiks_dl_text_unittests.cc.

                                                       {
   AiksContext aiks_context(GetContext(),
                            std::make_shared<TypographerContextSkia>());
  
   // Verifies that TextContents only use the scale/transform that is
   // computed during preroll.
   constexpr const char* font_fixture = "Roboto-Regular.ttf";
  
   // Construct the text blob.
   auto c_font_fixture = std::string(font_fixture);
   auto mapping = flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
   ASSERT_TRUE(mapping);
  
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   SkFont sk_font(font_mgr->makeFromData(mapping), 16);
  
   auto blob = SkTextBlob::MakeFromString("Hello World", sk_font);
   ASSERT_TRUE(blob);
  
   auto text_frame = MakeTextFrameFromTextBlobSkia(blob);
  
   // Simulate recording the text frame during preroll.
   Matrix preroll_matrix =
       Matrix::MakeTranslateScale({1.5, 1.5, 1}, {100, 50, 0});
   Point preroll_point = Point{23, 45};
   {
     auto scale = TextFrame::RoundScaledFontSize(
         (preroll_matrix * Matrix::MakeTranslation(preroll_point))
             .GetMaxBasisLengthXY());
  
     aiks_context.GetContentContext().GetLazyGlyphAtlas()->AddTextFrame(
         text_frame,     //
         scale,          //
         preroll_point,  //
         preroll_matrix,
         std::nullopt  //
     );
   }
  
   // Now simulate rendering with a slightly different scale factor.
   RenderTarget render_target =
       aiks_context.GetContentContext()
           .GetRenderTargetCache()
           ->CreateOffscreenMSAA(*aiks_context.GetContext(), {100, 100}, 1);
  
   TextContents text_contents;
   text_contents.SetTextFrame(text_frame);
   text_contents.SetOffset(preroll_point);
   text_contents.SetScale(1.6);
   text_contents.SetColor(Color::Aqua());
  
   Matrix not_preroll_matrix =
       Matrix::MakeTranslateScale({1.5, 1.5, 1}, {100, 50, 0});
  
   Entity entity;
   entity.SetTransform(not_preroll_matrix);
  
   std::shared_ptr<CommandBuffer> command_buffer =
       aiks_context.GetContext()->CreateCommandBuffer();
   std::shared_ptr<RenderPass> render_pass =
       command_buffer->CreateRenderPass(render_target);
  
   EXPECT_TRUE(text_contents.Render(aiks_context.GetContentContext(), entity,
                                    *render_pass));
 }

References impeller::AiksContext::GetContentContext(), impeller::AiksContext::GetContext(), impeller::ContentContext::GetLazyGlyphAtlas(), impeller::ContentContext::GetRenderTargetCache(), impeller::MakeTextFrameFromTextBlobSkia(), impeller::TextContents::Render(), impeller::TextContents::SetColor(), impeller::TextContents::SetOffset(), impeller::TextContents::SetScale(), impeller::TextContents::SetTextFrame(), and impeller::Entity::SetTransform().

◆ TEST_P() [296/545]

impeller::testing::TEST_P	(	AiksTest	,
		TextForegroundShaderWithTransform
	)

Definition at line 592 of file aiks_dl_text_unittests.cc.

                                                     {
   auto mapping = flutter::testing::OpenFixtureAsSkData("Roboto-Regular.ttf");
   ASSERT_NE(mapping, nullptr);
  
   Scalar font_size = 100;
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   SkFont sk_font(font_mgr->makeFromData(mapping), font_size);
  
   DlPaint text_paint;
   text_paint.setColor(DlColor::kBlue());
  
   std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                  DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0)};
   std::vector<Scalar> stops = {
       0.0,
       1.0,
   };
   text_paint.setColorSource(DlColorSource::MakeLinear(
       /*start_point=*/DlPoint(0, 0),     //
       /*end_point=*/DlPoint(100, 100),   //
       /*stop_count=*/2,                  //
       /*colors=*/colors.data(),          //
       /*stops=*/stops.data(),            //
       /*tile_mode=*/DlTileMode::kRepeat  //
       ));
  
   DisplayListBuilder builder;
   builder.Translate(100, 100);
   builder.Rotate(45);
  
   auto blob = SkTextBlob::MakeFromString("Hello", sk_font);
   ASSERT_NE(blob, nullptr);
   auto frame = MakeTextFrameFromTextBlobSkia(blob);
   builder.DrawTextFrame(frame, 0, 0, text_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References font_size, and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [297/545]

impeller::testing::TEST_P	(	AiksTest	,
		TextFrameSubpixelAlignment
	)

Definition at line 316 of file aiks_dl_text_unittests.cc.

                                              {
   // "Random" numbers between 0 and 1. Hardcoded to avoid flakiness in goldens.
   std::array<Scalar, 20> phase_offsets = {
       7.82637e-06, 0.131538,  0.755605,   0.45865,   0.532767,
       0.218959,    0.0470446, 0.678865,   0.679296,  0.934693,
       0.383502,    0.519416,  0.830965,   0.0345721, 0.0534616,
       0.5297,      0.671149,  0.00769819, 0.383416,  0.0668422};
   auto callback = [&]() -> sk_sp<DisplayList> {
     static float font_size = 20;
     static float phase_variation = 0.2;
     static float speed = 0.5;
     static float magnitude = 100;
     if (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();
     }
  
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
  
     for (size_t i = 0; i < phase_offsets.size(); i++) {
       DlPoint position = DlPoint(
           200 +
               magnitude * std::sin((-phase_offsets[i] * k2Pi * phase_variation +
                                     GetSecondsElapsed() * speed)),  //
           200 + i * font_size * 1.1                                 //
       );
       if (!RenderTextInCanvasSkia(
               GetContext(), builder,
               "the quick brown fox jumped over "
               "the lazy dog!.?",
               "Roboto-Regular.ttf",
               {.font_size = font_size, .position = position})) {
         return nullptr;
       }
     }
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References font_size, impeller::k2Pi, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [298/545]

impeller::testing::TEST_P	(	AiksTest	,
		TextRotated
	)

Definition at line 488 of file aiks_dl_text_unittests.cc.

                               {
   DisplayListBuilder builder;
  
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setColor(DlColor::ARGB(0.1, 0.1, 0.1, 1.0));
   builder.DrawPaint(paint);
  
   builder.Transform(Matrix(0.25, -0.3, 0, -0.002,  //
                            0, 0.5, 0, 0,           //
                            0, 0, 0.3, 0,           //
                            100, 100, 0, 1.3));
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
       "Roboto-Regular.ttf"));
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References RenderTextInCanvasSkia(), and x.

◆ TEST_P() [299/545]

impeller::testing::TEST_P	(	AiksTest	,
		TextRotated180Degrees
	)

Definition at line 279 of file aiks_dl_text_unittests.cc.

                                         {
   float fpivot[2] = {200 + 30, 200 - 20};
   float rotation = 180;
   float foffset[2] = {200, 200};
  
   auto callback = [&]() -> sk_sp<DisplayList> {
     if (AiksTest::ImGuiBegin("Controls", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
       ImGui::SliderFloat("pivotx", &fpivot[0], 0, 300);
       ImGui::SliderFloat("pivoty", &fpivot[1], 0, 300);
       ImGui::SliderFloat("rotation", &rotation, 0, 360);
       ImGui::SliderFloat("foffsetx", &foffset[0], 0, 300);
       ImGui::SliderFloat("foffsety", &foffset[1], 0, 300);
       ImGui::End();
     }
     DisplayListBuilder builder;
     builder.Scale(GetContentScale().x, GetContentScale().y);
     builder.DrawPaint(DlPaint().setColor(DlColor(0xffffeeff)));
  
     builder.Save();
     DlPoint pivot = Point(fpivot[0], fpivot[1]);
     builder.Translate(pivot.x, pivot.y);
     builder.Rotate(rotation);
     builder.Translate(-pivot.x, -pivot.y);
  
     RenderTextInCanvasSkia(GetContext(), builder, "test", "Roboto-Regular.ttf",
                            TextRenderOptions{
                                .color = DlColor::kBlack(),
                                .position = DlPoint(foffset[0], foffset[1]),
                            });
  
     builder.Restore();
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::testing::TextRenderOptions::color, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [300/545]

impeller::testing::TEST_P	(	AiksTest	,
		TextWithShadowCache
	)

Definition at line 773 of file aiks_dl_text_unittests.cc.

                                       {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
  
   AiksContext aiks_context(GetContext(),
                            std::make_shared<TypographerContextSkia>());
   // Cache empty
   EXPECT_EQ(aiks_context.GetContentContext()
                 .GetTextShadowCache()
                 .GetCacheSizeForTesting(),
             0u);
  
   ASSERT_TRUE(RenderTextInCanvasSkia(
       GetContext(), builder, "Hello World", kFontFixture,
       TextRenderOptions{
           .color = DlColor::kBlue(),
           .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)}));
  
   DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
  
   // Text should be cached.
   EXPECT_EQ(aiks_context.GetContentContext()
                 .GetTextShadowCache()
                 .GetCacheSizeForTesting(),
             1u);
 }

References impeller::testing::TextRenderOptions::color, impeller::DisplayListToTexture(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), impeller::ContentContext::GetTextShadowCache(), kFontFixture, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [301/545]

impeller::testing::TEST_P	(	AiksTest	,
		ToImageFromImage
	)

Definition at line 1042 of file aiks_dl_unittests.cc.

                                    {
   DisplayListBuilder builder;
   DlPath path = DlPath::MakeArc(DlRect::MakeLTRB(0, 0, 100, 100), DlDegrees(0),
                                 DlDegrees(90),
                                 /*use_center=*/true);
  
   builder.DrawPath(path, DlPaint().setColor(DlColor::kRed()));
  
   AiksContext renderer(GetContext(), nullptr);
   auto texture =
       DisplayListToTexture(builder.Build(), ISize(100, 100), renderer);
  
   // First, Readback the texture data into a host buffer.
   impeller::DeviceBufferDescriptor desc;
   desc.size = texture->GetTextureDescriptor().GetByteSizeOfBaseMipLevel();
   desc.readback = true;
   desc.storage_mode = StorageMode::kHostVisible;
  
   auto device_buffer = GetContext()->GetResourceAllocator()->CreateBuffer(desc);
   {
     auto cmd_buffer = GetContext()->CreateCommandBuffer();
     auto blit_pass = cmd_buffer->CreateBlitPass();
  
     blit_pass->AddCopy(texture, device_buffer);
     blit_pass->EncodeCommands();
  
     auto latch = std::make_shared<fml::CountDownLatch>(1u);
     GetContext()->GetCommandQueue()->Submit(
         {cmd_buffer},
         [latch](CommandBuffer::Status status) { latch->CountDown(); });
     latch->Wait();
   }
  
   impeller::TextureDescriptor tex_desc = texture->GetTextureDescriptor();
   auto reupload_texture =
       GetContext()->GetResourceAllocator()->CreateTexture(tex_desc);
  
   // Next, Re-upload the data into a new texture.
   {
     auto cmd_buffer = GetContext()->CreateCommandBuffer();
     auto blit_pass = cmd_buffer->CreateBlitPass();
     blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer),
                        reupload_texture);
     blit_pass->ConvertTextureToShaderRead(texture);
     blit_pass->EncodeCommands();
  
     auto latch = std::make_shared<fml::CountDownLatch>(1u);
     GetContext()->GetCommandQueue()->Submit(
         {cmd_buffer},
         [latch](CommandBuffer::Status status) { latch->CountDown(); });
     latch->Wait();
   }
  
   // Draw the results side by side. These should look the same.
   DisplayListBuilder canvas;
   DlPaint paint = DlPaint();
   canvas.DrawRect(
       DlRect::MakeLTRB(0, 0, 100, 100),
       DlPaint().setColor(DlColor::kBlue()).setDrawStyle(DlDrawStyle::kStroke));
   canvas.DrawImage(DlImageImpeller::Make(texture), DlPoint(0, 0),
                    DlImageSampling::kNearestNeighbor, &paint);
  
   canvas.DrawRect(
       DlRect::MakeLTRB(0, 100, 100, 200),
       DlPaint().setColor(DlColor::kRed()).setDrawStyle(DlDrawStyle::kStroke));
   canvas.DrawImage(DlImageImpeller::Make(reupload_texture), DlPoint(0, 100),
                    DlImageSampling::kNearestNeighbor, &paint);
   OpenPlaygroundHere(canvas.Build());
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::DisplayListToTexture(), impeller::kHostVisible, impeller::DlImageImpeller::Make(), impeller::DeviceBufferDescriptor::readback, impeller::DeviceBufferDescriptor::size, and impeller::DeviceBufferDescriptor::storage_mode.

◆ TEST_P() [302/545]

impeller::testing::TEST_P	(	AiksTest	,
		TransformMultipliesCorrectly
	)

Definition at line 70 of file canvas_unittests.cc.

                                                {
   ContentContext context(GetContext(), nullptr);
   auto canvas = CreateTestCanvas(context);
  
   ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(), Matrix());
  
   // clang-format off
   canvas->Translate(Vector3(100, 200));
   ASSERT_MATRIX_NEAR(
     canvas->GetCurrentTransform(),
     Matrix(  1,   0,   0,   0,
              0,   1,   0,   0,
              0,   0,   1,   0,
            100, 200,   0,   1));
  
   canvas->Rotate(Radians(kPiOver2));
   ASSERT_MATRIX_NEAR(
     canvas->GetCurrentTransform(),
     Matrix(  0,   1,   0,   0,
             -1,   0,   0,   0,
              0,   0,   1,   0,
            100, 200,   0,   1));
  
   canvas->Scale(Vector3(2, 3));
   ASSERT_MATRIX_NEAR(
     canvas->GetCurrentTransform(),
     Matrix(  0,   2,   0,   0,
             -3,   0,   0,   0,
              0,   0,   0,   0,
            100, 200,   0,   1));
  
   canvas->Translate(Vector3(100, 200));
   ASSERT_MATRIX_NEAR(
     canvas->GetCurrentTransform(),
     Matrix(   0,   2,   0,   0,
              -3,   0,   0,   0,
               0,   0,   0,   0,
            -500, 400,   0,   1));
   // clang-format on
 }

References ASSERT_MATRIX_NEAR, CreateTestCanvas(), and impeller::kPiOver2.

◆ TEST_P() [303/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerDrawsCorrectly
	)

Definition at line 139 of file aiks_dl_unittests.cc.

                                                      {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
  
   DlPaint save_paint;
   save_paint.setColor(DlColor::kBlack().withAlpha(128));
   builder.SaveLayer(std::nullopt, &save_paint);
   builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [304/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerImageDrawsCorrectly
	)

Definition at line 250 of file aiks_dl_unittests.cc.

                                                           {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
   builder.DrawImage(image, DlPoint(100, 100), DlImageSampling::kMipmapLinear);
  
   DlPaint paint;
   paint.setColor(DlColor::kBlack().withAlpha(128));
   builder.SaveLayer(std::nullopt, &paint);
   builder.DrawImage(image, DlPoint(100, 500), DlImageSampling::kMipmapLinear);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [305/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly
	)

Definition at line 335 of file aiks_dl_unittests.cc.

                                                                           {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), paint);
  
   DlPaint save_paint;
   save_paint.setAlpha(128);
   save_paint.setBlendMode(DlBlendMode::kLighten);
   builder.SaveLayer(std::nullopt, &save_paint);
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kGreen());
   builder.DrawCircle(DlPoint(200, 200), 100, draw_paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [306/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly
	)

Definition at line 155 of file aiks_dl_unittests.cc.

                                                                          {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
  
   DlPaint save_paint;
   paint.setColor(DlColor::kBlack().withAlpha(128));
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver));
   builder.Save();
   builder.ClipRect(DlRect::MakeXYWH(100, 500, 300, 300));
   builder.SaveLayer(std::nullopt, &paint);
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), draw_paint);
   builder.Restore();
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [307/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly
	)

Definition at line 179 of file aiks_dl_unittests.cc.

                                                                          {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
  
   DlPaint save_paint;
   save_paint.setColor(DlColor::kBlack().withAlpha(128));
   save_paint.setImageFilter(DlImageFilter::MakeColorFilter(
       DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver)));
  
   builder.SaveLayer(std::nullopt, &save_paint);
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), draw_paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [308/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly
	)

Definition at line 201 of file aiks_dl_unittests.cc.

                                                                             {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   DlPaint paint;
   paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
  
   DlPaint save_paint;
   save_paint.setColor(DlColor::kBlack().withAlpha(128));
   save_paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver));
   builder.Save();
   builder.ClipRect(DlRect::MakeXYWH(100, 500, 300, 300));
   builder.SaveLayer(std::nullopt, &save_paint);
  
   DlPaint draw_paint;
   draw_paint.setColor(DlColor::kBlue());
   builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), draw_paint);
   builder.Restore();
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [309/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorFilterAndImageFilterDrawsCorrectly
	)

Definition at line 309 of file aiks_dl_unittests.cc.

                                                                         {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
   builder.DrawImage(image, DlPoint(100, 100), {});
  
   const float matrix[20] = {
       1, 0,   0, 0,   0,  //
       0, 1,   0, 0,   0,  //
       0, 0.2, 1, 0,   0,  //
       0, 0,   0, 0.5, 0   //
   };
   DlPaint paint;
   paint.setColor(DlColor::kBlack().withAlpha(128));
   paint.setImageFilter(
       DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix)));
   paint.setColorFilter(
       DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kModulate));
   builder.SaveLayer(std::nullopt, &paint);
   builder.DrawImage(image, DlPoint(100, 500), {});
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [310/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly
	)

Definition at line 265 of file aiks_dl_unittests.cc.

                                                                                {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
   builder.DrawImage(image, DlPoint(100, 100), {});
  
   const float matrix[20] = {
       1, 0, 0, 0, 0,  //
       0, 1, 0, 0, 0,  //
       0, 0, 1, 0, 0,  //
       0, 0, 0, 2, 0   //
   };
   DlPaint paint;
   paint.setColor(DlColor::kBlack().withAlpha(128));
   paint.setColorFilter(DlColorFilter::MakeMatrix(matrix));
   builder.SaveLayer(std::nullopt, &paint);
   builder.DrawImage(image, DlPoint(100, 500), {});
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [311/545]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly
	)

Definition at line 287 of file aiks_dl_unittests.cc.

                                                                                {
   DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  
   auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
   builder.DrawImage(image, DlPoint(100, 100), {});
  
   const float matrix[20] = {
       1, 0, 0, 0, 0,  //
       0, 1, 0, 0, 0,  //
       0, 0, 1, 0, 0,  //
       0, 0, 0, 2, 0   //
   };
   DlPaint paint;
   paint.setColor(DlColor::kBlack().withAlpha(128));
   paint.setColorFilter(DlColorFilter::MakeMatrix(matrix));
   builder.SaveLayer(std::nullopt, &paint);
   builder.DrawImage(image, DlPoint(100, 500), {});
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [312/545]

impeller::testing::TEST_P	(	AiksTest	,
		TransparentShadowProducesCorrectColor
	)

Definition at line 858 of file aiks_dl_unittests.cc.

                                                         {
   DisplayListBuilder builder;
   builder.Save();
   builder.Scale(1.618, 1.618);
   DlPath path = DlPath::MakeRect(DlRect::MakeXYWH(0, 0, 200, 100));
  
   builder.DrawShadow(path, flutter::DlColor::kTransparent(), 15, false, 1);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [313/545]

impeller::testing::TEST_P	(	AiksTest	,
		TwoContourPathWithSinglePointContour
	)

Definition at line 967 of file aiks_dl_path_unittests.cc.

                                                        {
   DisplayListBuilder builder;
  
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   paint.setDrawStyle(DlDrawStyle::kStroke);
   paint.setStrokeWidth(15.0);
   paint.setStrokeCap(DlStrokeCap::kRound);
  
   DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(100, 100));
   path_builder.LineTo(DlPoint(150, 150));
   path_builder.MoveTo(DlPoint(200, 200));
   path_builder.LineTo(DlPoint(200, 200));
  
   builder.DrawPath(path_builder.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [314/545]

impeller::testing::TEST_P	(	AiksTest	,
		VarietyOfTextScalesShowingRasterAndPath
	)

Definition at line 876 of file aiks_dl_text_unittests.cc.

                                                           {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
   builder.DrawPaint(paint);
   builder.Scale(GetContentScale().x, GetContentScale().y);
  
   std::vector<Scalar> scales = {4, 8, 16, 24, 32};
   std::vector<Scalar> spacing = {8, 8, 8, 8, 8};
   Scalar space = 16;
   Scalar x = 0;
   for (auto i = 0u; i < scales.size(); i++) {
     builder.Save();
     builder.Scale(scales[i], scales[i]);
     RenderTextInCanvasSkia(
         GetContext(), builder, "lo", "Roboto-Regular.ttf",
         TextRenderOptions{.font_size = 16, .position = DlPoint(x, space)});
     space += spacing[i];
     if (i == 3) {
       x = 10;
       space = 16;
     }
     builder.Restore();
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::testing::TextRenderOptions::font_size, RenderTextInCanvasSkia(), and x.

◆ TEST_P() [315/545]

impeller::testing::TEST_P	(	AiksTest	,
		VerifyNonOptimizedGradient
	)

Definition at line 916 of file aiks_dl_gradient_unittests.cc.

                                              {
   DisplayListBuilder builder;
   DlPaint paint;
   builder.Translate(100.0f, 0);
  
   std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                  DlColor::kGreen()};
   std::vector<Scalar> stops = {0.0, 0.1, 1.0};
  
   // Inset the start and end point to verify that we do not apply
   // the fast gradient condition.
   paint.setColorSource(
       DlColorSource::MakeLinear({0, 150}, {0, 100}, stops.size(), colors.data(),
                                 stops.data(), DlTileMode::kRepeat));
  
   paint.setColor(DlColor::kWhite());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
   builder.Translate(400, 0);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [316/545]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryColorUVPositionData
	)

Definition at line 97 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(
       DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp));
  
   std::vector<DlPoint> positions = {
       DlPoint(0, 0),           DlPoint(size.width, 0),
       DlPoint(0, size.height), DlPoint(size.width, 0),
       DlPoint(0, 0),           DlPoint(size.width, size.height),
   };
   std::vector<DlColor> colors = {
       DlColor::kRed().withAlpha(128),   DlColor::kBlue().withAlpha(128),
       DlColor::kGreen().withAlpha(128), DlColor::kRed().withAlpha(128),
       DlColor::kBlue().withAlpha(128),  DlColor::kGreen().withAlpha(128),
   };
  
   auto vertices =
       MakeVertices(DlVertexMode::kTriangles, positions, {}, {}, colors);
  
   builder.DrawVertices(vertices, DlBlendMode::kDstOver, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [317/545]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryColorUVPositionDataAdvancedBlend
	)

Definition at line 125 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(
       DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp));
  
   std::vector<DlPoint> positions = {
       DlPoint(0, 0),           DlPoint(size.width, 0),
       DlPoint(0, size.height), DlPoint(size.width, 0),
       DlPoint(0, 0),           DlPoint(size.width, size.height),
   };
   std::vector<DlColor> colors = {
       DlColor::kRed().modulateOpacity(0.5),
       DlColor::kBlue().modulateOpacity(0.5),
       DlColor::kGreen().modulateOpacity(0.5),
       DlColor::kRed().modulateOpacity(0.5),
       DlColor::kBlue().modulateOpacity(0.5),
       DlColor::kGreen().modulateOpacity(0.5),
   };
  
   auto vertices =
       MakeVertices(DlVertexMode::kTriangles, positions, {}, {}, colors);
  
   builder.DrawVertices(vertices, DlBlendMode::kColorBurn, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [318/545]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryUVPositionData
	)

Definition at line 49 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(
       DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp));
  
   std::vector<DlPoint> vertex_coordinates = {
       DlPoint(0, 0),
       DlPoint(size.width, 0),
       DlPoint(0, size.height),
   };
   auto vertices = MakeVertices(DlVertexMode::kTriangleStrip, vertex_coordinates,
                                {0, 1, 2}, {}, {});
  
   builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [319/545]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryUVPositionDataWithTranslate
	)

Definition at line 72 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();
  
   DlMatrix matrix = DlMatrix::MakeTranslation({100, 100});
   paint.setColorSource(
       DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp,
                                DlImageSampling::kLinear, &matrix));
  
   std::vector<DlPoint> positions = {
       DlPoint(0, 0),
       DlPoint(size.width, 0),
       DlPoint(0, size.height),
   };
   auto vertices =
       MakeVertices(DlVertexMode::kTriangleStrip, positions, {0, 1, 2}, {}, {});
  
   builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [320/545]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryWithMaskFilter
	)

Definition at line 555 of file aiks_dl_vertices_unittests.cc.

                                                  {
   DisplayListBuilder builder;
   DlPaint paint;
   paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10));
  
   std::vector<DlPoint> vertex_coordinates = {
       DlPoint(0, 0),
       DlPoint(400, 0),
       DlPoint(0, 400),
   };
   auto vertices = MakeVertices(DlVertexMode::kTriangleStrip, vertex_coordinates,
                                {0, 1, 2}, {}, {});
  
   builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [321/545]

impeller::testing::TEST_P	(	AllocatorMTLTest	,
		DebugTraceMemoryStatistics
	)

Definition at line 28 of file allocator_mtl_unittests.mm.

                                                      {
   auto& context_mtl = ContextMTL::Cast(*GetContext());
   const auto& allocator = context_mtl.GetResourceAllocator();
  
   EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
             0u);
  
   // Memoryless texture does not increase allocated size.
   {
     TextureDescriptor desc;
     desc.format = PixelFormat::kR8G8B8A8UNormInt;
     desc.storage_mode = StorageMode::kDeviceTransient;
     desc.size = {1024, 1024};
     auto texture_1 = allocator->CreateTexture(desc);
  
     // Private storage texture increases allocated size.
     desc.storage_mode = StorageMode::kDevicePrivate;
     auto texture_2 = allocator->CreateTexture(desc);
  
 #ifdef IMPELLER_DEBUG
     EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
               4u);
 #else
     EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
               0u);
 #endif  // IMPELLER_DEBUG
  
     // Host storage texture increases allocated size.
     desc.storage_mode = StorageMode::kHostVisible;
     auto texture_3 = allocator->CreateTexture(desc);
  
 #ifdef IMPELLER_DEBUG
     EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
               8u);
 #else
     EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
               0u);
 #endif  // IMPELLER_DEBUG
   }
  
   // After all textures are out of scope, memory has been decremented.
   EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
             0u);
 }

References impeller::BackendCast< ContextMTL, Context >::Cast(), impeller::TextureDescriptor::format, impeller::AllocationSize< Period >::GetSize(), impeller::kDevicePrivate, impeller::kDeviceTransient, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [322/545]

impeller::testing::TEST_P	(	AllocatorMTLTest	,
		ManagedMemory
	)

Definition at line 73 of file allocator_mtl_unittests.mm.

                                         {
   auto& context_mtl = ContextMTL::Cast(*GetContext());
   auto allocator = std::make_unique<AllocatorMTL>(context_mtl.GetMTLDevice(),
                                                   "test-allocator");
   allocator->DebugSetSupportsUMA(false);
  
   DeviceBufferDescriptor desc;
   desc.size = 100;
   desc.storage_mode = StorageMode::kHostVisible;
  
   auto buffer = allocator->CreateBuffer(desc);
   ASSERT_TRUE(buffer);
  
   EXPECT_NE(buffer->OnGetContents(), nullptr);
 }

References impeller::BackendCast< ContextMTL, Context >::Cast(), impeller::kHostVisible, impeller::DeviceBufferDescriptor::size, and impeller::DeviceBufferDescriptor::storage_mode.

◆ TEST_P() [323/545]

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.GetRange().offset, 4u);
   EXPECT_EQ(buffer_view.GetRange().length, 1u);
   Entity entity;
  
   std::optional<Entity> result = filter_contents.GetEntity(
       *renderer, entity, /*coverage_hint=*/std::nullopt);
  
   EXPECT_TRUE(result.has_value());
 }

References buffer_view, impeller::FilterContents::GetEntity(), impeller::kColorDodge, impeller::FilterInput::Make(), impeller::BlendFilterContents::SetBlendMode(), impeller::BlendFilterContents::SetForegroundColor(), and impeller::FilterContents::SetInputs().

◆ TEST_P() [324/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitAcrossDifferentPixelFormatsFails
	)

Definition at line 30 of file blit_pass_unittests.cc.

                                                            {
   ScopedValidationDisable scope;  // avoid noise in output.
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor src_desc;
   src_desc.format = PixelFormat::kA8UNormInt;
   src_desc.size = {100, 100};
   src_desc.storage_mode = StorageMode::kHostVisible;
   auto src = context->GetResourceAllocator()->CreateTexture(src_desc);
  
   TextureDescriptor dst_format;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {100, 100};
   dst_format.storage_mode = StorageMode::kHostVisible;
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   EXPECT_FALSE(blit_pass->AddCopy(src, dst));
 }

References impeller::TextureDescriptor::format, impeller::kA8UNormInt, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [325/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitAcrossDifferentSampleCountsFails
	)

Definition at line 51 of file blit_pass_unittests.cc.

                                                            {
   ScopedValidationDisable scope;  // avoid noise in output.
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor src_desc;
   src_desc.format = PixelFormat::kR8G8B8A8UNormInt;
   src_desc.sample_count = SampleCount::kCount4;
   src_desc.size = {100, 100};
   auto src = context->GetResourceAllocator()->CreateTexture(src_desc);
  
   TextureDescriptor dst_format;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {100, 100};
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   EXPECT_FALSE(blit_pass->AddCopy(src, dst));
 }

References impeller::TextureDescriptor::format, impeller::kCount4, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::sample_count, and impeller::TextureDescriptor::size.

◆ TEST_P() [326/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitPassesForMatchingFormats
	)

Definition at line 71 of file blit_pass_unittests.cc.

                                                    {
   ScopedValidationDisable scope;  // avoid noise in output.
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor src_desc;
   src_desc.format = PixelFormat::kR8G8B8A8UNormInt;
   src_desc.size = {100, 100};
   src_desc.storage_mode = StorageMode::kHostVisible;
   auto src = context->GetResourceAllocator()->CreateTexture(src_desc);
  
   TextureDescriptor dst_format;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {100, 100};
   dst_format.storage_mode = StorageMode::kHostVisible;
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   EXPECT_TRUE(blit_pass->AddCopy(src, dst));
 }

References impeller::TextureDescriptor::format, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [327/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanBlitSmallRegionToUninitializedTexture
	)

Definition at line 123 of file blit_pass_unittests.cc.

                                                                {
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor dst_format;
   dst_format.storage_mode = StorageMode::kDevicePrivate;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {1000, 1000};
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   DeviceBufferDescriptor src_format;
   src_format.size = 4;
   src_format.storage_mode = StorageMode::kHostVisible;
   auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
  
   ASSERT_TRUE(dst);
  
   EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  IRect::MakeLTRB(0, 0, 1, 1), "",
                                  /*mip_level=*/0, /*slice=*/0));
   EXPECT_TRUE(blit_pass->EncodeCommands());
   EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeLTRB(), impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [328/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanBlitToHigherTextureMipLevels
	)

Definition at line 176 of file blit_pass_unittests.cc.

                                                       {
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor dst_format;
   dst_format.storage_mode = StorageMode::kDevicePrivate;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {1000, 1000};
   dst_format.mip_count = 4;
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   DeviceBufferDescriptor src_format;
   src_format.size = 4;
   src_format.storage_mode = StorageMode::kHostVisible;
   auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
  
   ASSERT_TRUE(dst);
  
   EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  IRect::MakeLTRB(0, 0, 1, 1), "",
                                  /*mip_level=*/1, /*slice=*/0));
   EXPECT_TRUE(blit_pass->EncodeCommands());
   EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeLTRB(), impeller::TextureDescriptor::mip_count, impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [329/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanResizeTextures
	)

Definition at line 202 of file blit_pass_unittests.cc.

                                         {
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor dst_format;
   dst_format.storage_mode = StorageMode::kDevicePrivate;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {10, 10};
   dst_format.usage = TextureUsage::kShaderRead | TextureUsage::kShaderWrite;
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   TextureDescriptor src_format;
   src_format.storage_mode = StorageMode::kDevicePrivate;
   src_format.format = PixelFormat::kR8G8B8A8UNormInt;
   src_format.size = {100, 100};
   auto src = context->GetResourceAllocator()->CreateTexture(src_format);
  
   std::vector<uint8_t> bytes(src_format.GetByteSizeOfBaseMipLevel());
   for (auto i = 0u; i < src_format.GetByteSizeOfBaseMipLevel(); i += 4) {
     // RGBA
     bytes[i + 0] = 255;
     bytes[i + 1] = 0;
     bytes[i + 2] = 0;
     bytes[i + 3] = 255;
   }
   auto mapping = fml::DataMapping(bytes);
   auto staging = context->GetResourceAllocator()->CreateBufferWithCopy(mapping);
  
   ASSERT_TRUE(dst);
   ASSERT_TRUE(src);
   ASSERT_TRUE(staging);
  
   EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(staging), src));
   EXPECT_TRUE(blit_pass->ResizeTexture(src, dst));
   EXPECT_TRUE(blit_pass->EncodeCommands());
   EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kShaderRead, impeller::kShaderWrite, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and impeller::TextureDescriptor::usage.

◆ TEST_P() [330/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanResizeTexturesPlayground
	)

Definition at line 241 of file blit_pass_unittests.cc.

                                                   {
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   std::shared_ptr<Texture> src = CreateTextureForFixture("kalimba.jpg");
  
   TextureDescriptor dst_format;
   dst_format.storage_mode = StorageMode::kDevicePrivate;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {src->GetSize().width / 2, src->GetSize().height};
   dst_format.usage = TextureUsage::kShaderRead | TextureUsage::kShaderWrite;
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   ASSERT_TRUE(dst);
   ASSERT_TRUE(src);
  
   EXPECT_TRUE(blit_pass->ResizeTexture(src, dst));
   EXPECT_TRUE(blit_pass->EncodeCommands());
   EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
  
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
   DlPaint paint;
   paint.setColor(DlColor::kRed());
   auto image = DlImageImpeller::Make(dst);
   builder.DrawImage(image, flutter::DlPoint(100.0, 100.0),
                     DlImageSampling::kNearestNeighbor, &paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kShaderRead, impeller::kShaderWrite, impeller::DlImageImpeller::Make(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::TextureDescriptor::usage, impeller::TSize< T >::width, and x.

◆ TEST_P() [331/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		ChecksInvalidMipLevelParameter
	)

Definition at line 148 of file blit_pass_unittests.cc.

                                                      {
   ScopedValidationDisable scope;
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor dst_format;
   dst_format.storage_mode = StorageMode::kDevicePrivate;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {1000, 1000};
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   DeviceBufferDescriptor src_format;
   src_format.size = 4;
   src_format.storage_mode = StorageMode::kHostVisible;
   auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
  
   ASSERT_TRUE(dst);
  
   EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                   IRect::MakeLTRB(0, 0, 1, 1), "",
                                   /*mip_level=*/1, /*slice=*/0));
  
   EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  IRect::MakeLTRB(0, 0, 1, 1), "",
                                  /*mip_level=*/0, /*slice=*/0));
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeLTRB(), impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [332/545]

impeller::testing::TEST_P	(	BlitPassTest	,
		ChecksInvalidSliceParameters
	)

Definition at line 92 of file blit_pass_unittests.cc.

                                                    {
   ScopedValidationDisable scope;  // avoid noise in output.
   auto context = GetContext();
   auto cmd_buffer = context->CreateCommandBuffer();
   auto blit_pass = cmd_buffer->CreateBlitPass();
  
   TextureDescriptor dst_format;
   dst_format.storage_mode = StorageMode::kDevicePrivate;
   dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
   dst_format.size = {100, 100};
   auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
  
   DeviceBufferDescriptor src_format;
   src_format.size = 40000;
   src_format.storage_mode = StorageMode::kHostVisible;
   auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
  
   ASSERT_TRUE(dst);
   ASSERT_TRUE(src);
  
   EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                   std::nullopt, "", /*mip_level=*/0,
                                   /*slice=*/25));
   EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                   std::nullopt, "", /*mip_level=*/0,
                                   /*slice=*/6));
   EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  std::nullopt, "", /*mip_level=*/0,
                                  /*slice=*/0));
 }

References impeller::DeviceBuffer::AsBufferView(), impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [333/545]

impeller::testing::TEST_P	(	ComputeTest	,
		1DThreadgroupSizingIsCorrect
	)

Definition at line 177 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.GetRange().length,
                                sizeof(CS::OutputData<kCount>));
  
                      CS::OutputData<kCount>* output =
                          reinterpret_cast<CS::OutputData<kCount>*>(
                              output_buffer->OnGetContents());
                      EXPECT_TRUE(output);
                      EXPECT_EQ(output->data[kCount - 1], kCount - 1);
                      latch.Signal();
                    })
           .ok());
  
   latch.Wait();
 }

◆ TEST_P() [334/545]

impeller::testing::TEST_P	(	ComputeTest	,
		CanCompute1DimensionalData
	)

Definition at line 377 of file compute_unittests.cc.

                                                 {
   using CS = SampleComputeShader;
   auto context = GetContext();
   auto host_buffer = HostBuffer::Create(context->GetResourceAllocator(),
                                         context->GetIdleWaiter());
   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.GetRange().length, sizeof(CS::Output<kCount>));
  
                 CS::Output<kCount>* output =
                     reinterpret_cast<CS::Output<kCount>*>(
                         output_buffer->OnGetContents());
                 EXPECT_TRUE(output);
                 for (size_t i = 0; i < kCount; i++) {
                   Vector4 vector = output->elements[i];
                   Vector4 computed = input_0.elements[i] * input_1.elements[i];
                   EXPECT_EQ(vector,
                             Vector4(computed.x + 2 + input_1.some_struct.i,
                                     computed.y + 3 + input_1.some_struct.vf.x,
                                     computed.z + 5 + input_1.some_struct.vf.y,
                                     computed.w));
                 }
                 latch.Signal();
               })
           .ok());
  
   latch.Wait();
 }

References impeller::interop::Create().

◆ TEST_P() [335/545]

impeller::testing::TEST_P	(	ComputeTest	,
		CanComputePrefixSum
	)

Definition at line 110 of file compute_unittests.cc.

                                          {
   using CS = PrefixSumTestComputeShader;
   auto context = GetContext();
   auto host_buffer = HostBuffer::Create(context->GetResourceAllocator(),
                                         context->GetIdleWaiter());
   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.GetRange().length,
                                sizeof(CS::OutputData<kCount>));
  
                      CS::OutputData<kCount>* output =
                          reinterpret_cast<CS::OutputData<kCount>*>(
                              output_buffer->OnGetContents());
                      EXPECT_TRUE(output);
  
                      constexpr uint32_t expected[kCount] = {1, 3, 6, 10, 15};
                      for (size_t i = 0; i < kCount; i++) {
                        auto computed_sum = output->data[i];
                        EXPECT_EQ(computed_sum, expected[i]);
                      }
                      latch.Signal();
                    })
           .ok());
  
   latch.Wait();
 }

References impeller::DeviceBuffer::AsBufferView(), and impeller::HostBuffer::Create().

◆ TEST_P() [336/545]

impeller::testing::TEST_P	(	ComputeTest	,
		CanComputePrefixSumLargeInteractive
	)

Definition at line 230 of file compute_unittests.cc.

                                                          {
   using CS = PrefixSumTestComputeShader;
  
   auto context = GetContext();
   auto host_buffer = HostBuffer::Create(context->GetResourceAllocator(),
                                         context->GetIdleWaiter());
  
   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));
 }

References impeller::interop::Create().

◆ TEST_P() [337/545]

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(),
                                         context->GetIdleWaiter());
   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.GetRange().length, sizeof(CS::Output<kCount>));
  
                 CS::Output<kCount>* output =
                     reinterpret_cast<CS::Output<kCount>*>(
                         output_buffer->OnGetContents());
                 EXPECT_TRUE(output);
                 for (size_t i = 0; i < kCount; i++) {
                   Vector4 vector = output->elements[i];
                   Vector4 computed = input_0.elements[i] * input_1.elements[i];
                   EXPECT_EQ(vector,
                             Vector4(computed.x + 2 + input_1.some_struct.i,
                                     computed.y + 3 + input_1.some_struct.vf.x,
                                     computed.z + 5 + input_1.some_struct.vf.y,
                                     computed.w));
                 }
                 latch.Signal();
               })
           .ok());
  
   latch.Wait();
 }

References impeller::DeviceBuffer::AsBufferView(), and impeller::HostBuffer::Create().

◆ TEST_P() [338/545]

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() [339/545]

impeller::testing::TEST_P	(	ComputeTest	,
		MultiStageInputAndOutput
	)

Definition at line 274 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(),
                                         context->GetIdleWaiter());
   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();
 }

References impeller::interop::Create(), and impeller::kCount1.

◆ TEST_P() [340/545]

impeller::testing::TEST_P	(	ComputeTest	,
		ReturnsEarlyWhenAnyGridDimensionIsZero
	)

Definition at line 457 of file compute_unittests.cc.

                                                             {
   using CS = SampleComputeShader;
   auto context = GetContext();
   auto host_buffer = HostBuffer::Create(context->GetResourceAllocator(),
                                         context->GetIdleWaiter());
   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();
 }

References impeller::interop::Create().

◆ TEST_P() [341/545]

impeller::testing::TEST_P	(	ContextMTLTest	,
		FlushTask
	)

Definition at line 28 of file context_mtl_unittests.mm.

                                   {
   auto& context_mtl = ContextMTL::Cast(*GetContext());
  
   int executed = 0;
   int failed = 0;
   context_mtl.StoreTaskForGPU([&]() { executed++; }, [&]() { failed++; });
  
   context_mtl.FlushTasksAwaitingGPU();
  
   EXPECT_EQ(executed, 1);
   EXPECT_EQ(failed, 0);
 }

References impeller::BackendCast< ContextMTL, Context >::Cast().

◆ TEST_P() [342/545]

impeller::testing::TEST_P	(	ContextMTLTest	,
		FlushTaskWithGPULoss
	)

Definition at line 41 of file context_mtl_unittests.mm.

                                              {
   auto& context_mtl = ContextMTL::Cast(*GetContext());
  
   int executed = 0;
   int failed = 0;
   context_mtl.StoreTaskForGPU([&]() { executed++; }, [&]() { failed++; });
  
   // If tasks are flushed while the GPU is disabled, then
   // they should not be executed.
   SetGPUDisabled(/*disabled=*/true);
   context_mtl.FlushTasksAwaitingGPU();
  
   EXPECT_EQ(executed, 0);
   EXPECT_EQ(failed, 0);
  
   // Toggling availibility should flush tasks.
   SetGPUDisabled(/*disabled=*/false);
  
   EXPECT_EQ(executed, 1);
   EXPECT_EQ(failed, 0);
 }

References impeller::BackendCast< ContextMTL, Context >::Cast().

◆ TEST_P() [343/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanBlendDstOverAndDstCorrectly
	)

Definition at line 1176 of file dl_unittests.cc.

                                                         {
   flutter::DisplayListBuilder builder;
  
   {
     builder.SaveLayer(std::nullopt, nullptr);
     builder.Translate(100, 100);
     flutter::DlPaint paint;
     paint.setColor(flutter::DlColor::kRed());
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
     paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     builder.Restore();
   }
   {
     builder.SaveLayer(std::nullopt, nullptr);
     builder.Translate(300, 100);
     flutter::DlPaint paint;
     paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     paint.setColor(flutter::DlColor::kRed());
     paint.setBlendMode(flutter::DlBlendMode::kDstOver);
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     builder.Restore();
   }
   {
     builder.SaveLayer(std::nullopt, nullptr);
     builder.Translate(100, 300);
     flutter::DlPaint paint;
     paint.setColor(flutter::DlColor::kRed());
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
     paint.setBlendMode(flutter::DlBlendMode::kSrc);
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     builder.Restore();
   }
   {
     builder.SaveLayer(std::nullopt, nullptr);
     builder.Translate(300, 300);
     flutter::DlPaint paint;
     paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     paint.setColor(flutter::DlColor::kRed());
     paint.setBlendMode(flutter::DlBlendMode::kDst);
     builder.DrawRect(DlRect::MakeWH(200, 200), paint);
     builder.Restore();
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [344/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanClampTheResultingColorOfColorMatrixFilter
	)

Definition at line 622 of file dl_unittests.cc.

                                                                       {
   auto texture = CreateTextureForFixture("boston.jpg");
   const float inner_color_matrix[20] = {
       1, 0, 0, 0, 0,  //
       0, 1, 0, 0, 0,  //
       0, 0, 1, 0, 0,  //
       0, 0, 0, 2, 0,  //
   };
   const float outer_color_matrix[20] = {
       1, 0, 0, 0,   0,  //
       0, 1, 0, 0,   0,  //
       0, 0, 1, 0,   0,  //
       0, 0, 0, 0.5, 0,  //
   };
   auto inner_color_filter =
       flutter::DlColorFilter::MakeMatrix(inner_color_matrix);
   auto outer_color_filter =
       flutter::DlColorFilter::MakeMatrix(outer_color_matrix);
   auto inner = flutter::DlImageFilter::MakeColorFilter(inner_color_filter);
   auto outer = flutter::DlImageFilter::MakeColorFilter(outer_color_filter);
   auto compose = std::make_shared<flutter::DlComposeImageFilter>(outer, inner);
  
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
   paint.setImageFilter(compose.get());
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor, &paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [345/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawAnOpenPath
	)

Definition at line 414 of file dl_unittests.cc.

                                            {
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setColor(flutter::DlColor::kRed());
   paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
   paint.setStrokeWidth(10);
  
   builder.Translate(300, 300);
  
   // Move to (50, 50) and draw lines from:
   // 1. (50, height)
   // 2. (width, height)
   // 3. (width, 50)
   flutter::DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(50, 50));
   path_builder.LineTo(DlPoint(50, 100));
   path_builder.LineTo(DlPoint(100, 100));
   path_builder.LineTo(DlPoint(100, 50));
   builder.DrawPath(path_builder.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [346/545]

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 = DlRect::MakeLTRB(p1.x, p1.y, p2.x, p2.y);
     paint.setColor(flutter::DlColor::kGreen());
     paint.setStrokeWidth(2);
     builder.DrawRect(rect, paint);
     paint.setColor(flutter::DlColor::kRed());
     paint.setStrokeWidth(stroke_width);
     builder.DrawArc(rect, start_angle, sweep_angle, use_center, paint);
  
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundLine(), use_center, impeller::Color::White(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [347/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawBackdropFilter
	)

Definition at line 652 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<DlRect> bounds;
     if (use_bounds) {
       static PlaygroundPoint point_a(Point(350, 150), 20, Color::White());
       static PlaygroundPoint point_b(Point(800, 600), 20, Color::White());
       auto [p1, p2] = DrawPlaygroundLine(point_a, point_b);
       bounds = DlRect::MakeLTRB(p1.x, p1.y, p2.x, p2.y);
     }
  
     // Insert a clip to test that the backdrop filter handles stencil depths > 0
     // correctly.
     if (add_clip) {
       builder.ClipRect(DlRect::MakeLTRB(0, 0, 99999, 99999),
                        flutter::DlClipOp::kIntersect, true);
     }
  
     builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                       flutter::DlImageSampling::kNearestNeighbor, nullptr);
     builder.SaveLayer(bounds, nullptr, &filter);
  
     if (draw_circle) {
       static PlaygroundPoint center_point(Point(500, 400), 20, Color::Red());
       auto circle_center = DrawPlaygroundPoint(center_point);
  
       flutter::DlPaint paint;
       paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
       paint.setStrokeCap(flutter::DlStrokeCap::kButt);
       paint.setStrokeJoin(flutter::DlStrokeJoin::kBevel);
       paint.setStrokeWidth(10);
       paint.setColor(flutter::DlColor::kRed().withAlpha(100));
       builder.DrawCircle(DlPoint(circle_center.x, circle_center.y), 100, paint);
     }
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DrawPlaygroundLine(), impeller::DrawPlaygroundPoint(), impeller::DlImageImpeller::Make(), impeller::Color::Red(), impeller::Color::White(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [348/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawCapsAndJoins
	)

Definition at line 103 of file dl_unittests.cc.

                                              {
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
   paint.setStrokeWidth(30);
   paint.setColor(flutter::DlColor::kRed());
  
   flutter::DlPathBuilder path_builder;
   path_builder.MoveTo(DlPoint(-50, 0));
   path_builder.LineTo(DlPoint(0, -50));
   path_builder.LineTo(DlPoint(50, 0));
   flutter::DlPath path = path_builder.TakePath();
  
   builder.Translate(100, 100);
   {
     paint.setStrokeCap(flutter::DlStrokeCap::kButt);
     paint.setStrokeJoin(flutter::DlStrokeJoin::kMiter);
     paint.setStrokeMiter(4);
     builder.DrawPath(path, paint);
   }
  
   {
     builder.Save();
     builder.Translate(0, 100);
     // The joint in the path is 45 degrees. A miter length of 1 convert to a
     // bevel in this case.
     paint.setStrokeMiter(1);
     builder.DrawPath(path, paint);
     builder.Restore();
   }
  
   builder.Translate(150, 0);
   {
     paint.setStrokeCap(flutter::DlStrokeCap::kSquare);
     paint.setStrokeJoin(flutter::DlStrokeJoin::kBevel);
     builder.DrawPath(path, paint);
   }
  
   builder.Translate(150, 0);
   {
     paint.setStrokeCap(flutter::DlStrokeCap::kRound);
     paint.setStrokeJoin(flutter::DlStrokeJoin::kRound);
     builder.DrawPath(path, paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [349/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawCorrectlyWithColorFilterAndImageFilter
	)

Definition at line 1227 of file dl_unittests.cc.

                                                                        {
   flutter::DisplayListBuilder builder;
   const float green_color_matrix[20] = {
       0, 0, 0, 0, 0,  //
       0, 0, 0, 0, 1,  //
       0, 0, 0, 0, 0,  //
       0, 0, 0, 1, 0,  //
   };
   const float blue_color_matrix[20] = {
       0, 0, 0, 0, 0,  //
       0, 0, 0, 0, 0,  //
       0, 0, 0, 0, 1,  //
       0, 0, 0, 1, 0,  //
   };
   auto green_color_filter =
       flutter::DlColorFilter::MakeMatrix(green_color_matrix);
   auto blue_color_filter =
       flutter::DlColorFilter::MakeMatrix(blue_color_matrix);
   auto blue_image_filter =
       flutter::DlImageFilter::MakeColorFilter(blue_color_filter);
  
   flutter::DlPaint paint;
   paint.setColor(flutter::DlColor::kRed());
   paint.setColorFilter(green_color_filter);
   paint.setImageFilter(blue_image_filter);
   builder.DrawRect(DlRect::MakeLTRB(100, 100, 500, 500), paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [350/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawImage
	)

Definition at line 95 of file dl_unittests.cc.

                                       {
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [351/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImage
	)

Definition at line 720 of file dl_unittests.cc.

                                                {
   // Image is drawn with corners to scale and center pieces stretched to fit.
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   auto size = texture->GetSize();
   builder.DrawImageNine(
       DlImageImpeller::Make(texture),
       DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                         size.height * 3 / 4),
       DlRect::MakeLTRB(0, 0, size.width * 2, size.height * 2),
       flutter::DlFilterMode::kNearest, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [352/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterBiggerThanDest
	)

Definition at line 766 of file dl_unittests.cc.

                                                                    {
   // Edge case, the width and height of the corners does not leave any
   // room for the center slices. Only the corners are displayed.
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   auto size = texture->GetSize();
   builder.DrawImageNine(
       DlImageImpeller::Make(texture),
       DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                         size.height * 3 / 4),
       DlRect::MakeLTRB(0, 0, size.width / 2, size.height / 2),
       flutter::DlFilterMode::kNearest, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [353/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterHeightBiggerThanDest
	)

Definition at line 750 of file dl_unittests.cc.

                                                                          {
   // Edge case, the height of the corners does not leave any room for the
   // center slice. The center (across the horizontal axis) is folded out of the
   // resulting image.
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   auto size = texture->GetSize();
   builder.DrawImageNine(
       DlImageImpeller::Make(texture),
       DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                         size.height * 3 / 4),
       DlRect::MakeLTRB(0, 0, size.width, size.height / 2),
       flutter::DlFilterMode::kNearest, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [354/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterWidthBiggerThanDest
	)

Definition at line 734 of file dl_unittests.cc.

                                                                         {
   // Edge case, the width of the corners does not leave any room for the
   // center slice. The center (across the vertical axis) is folded out of the
   // resulting image.
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   auto size = texture->GetSize();
   builder.DrawImageNine(
       DlImageImpeller::Make(texture),
       DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                         size.height * 3 / 4),
       DlRect::MakeLTRB(0, 0, size.width / 2, size.height),
       flutter::DlFilterMode::kNearest, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [355/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCornersScaledDown
	)

Definition at line 781 of file dl_unittests.cc.

                                                                 {
   // Edge case, there is not enough room for the corners to be drawn
   // without scaling them down.
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   auto size = texture->GetSize();
   builder.DrawImageNine(
       DlImageImpeller::Make(texture),
       DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                         size.height * 3 / 4),
       DlRect::MakeLTRB(0, 0, size.width / 4, size.height / 4),
       flutter::DlFilterMode::kNearest, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [356/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawPaintWithColorSource
	)

Definition at line 1124 of file dl_unittests.cc.

                                                      {
   const flutter::DlColor colors[2] = {
       flutter::DlColor(0xFFF44336),
       flutter::DlColor(0xFF2196F3),
   };
   const float stops[2] = {0.0, 1.0};
   flutter::DlPaint paint;
   flutter::DisplayListBuilder builder;
   auto clip_bounds = DlRect::MakeWH(300.0, 300.0);
   builder.Save();
   builder.Translate(100, 100);
   builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
   auto linear =
       flutter::DlColorSource::MakeLinear({0.0, 0.0}, {100.0, 100.0}, 2, colors,
                                          stops, flutter::DlTileMode::kRepeat);
   paint.setColorSource(linear);
   builder.DrawPaint(paint);
   builder.Restore();
  
   builder.Save();
   builder.Translate(500, 100);
   builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
   auto radial = flutter::DlColorSource::MakeRadial(
       {100.0, 100.0}, 100.0, 2, colors, stops, flutter::DlTileMode::kRepeat);
   paint.setColorSource(radial);
   builder.DrawPaint(paint);
   builder.Restore();
  
   builder.Save();
   builder.Translate(100, 500);
   builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
   auto sweep =
       flutter::DlColorSource::MakeSweep({100.0, 100.0}, 180.0, 270.0, 2, colors,
                                         stops, flutter::DlTileMode::kRepeat);
   paint.setColorSource(sweep);
   builder.DrawPaint(paint);
   builder.Restore();
  
   builder.Save();
   builder.Translate(500, 500);
   builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
   auto texture = CreateTextureForFixture("table_mountain_nx.png");
   auto image = flutter::DlColorSource::MakeImage(DlImageImpeller::Make(texture),
                                                  flutter::DlTileMode::kRepeat,
                                                  flutter::DlTileMode::kRepeat);
   paint.setColorSource(image);
   builder.DrawPaint(paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [357/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawPoints
	)

Definition at line 808 of file dl_unittests.cc.

                                        {
   flutter::DisplayListBuilder builder;
   DlPoint points[7] = {
       {0, 0},      //
       {100, 100},  //
       {100, 0},    //
       {0, 100},    //
       {0, 0},      //
       {48, 48},    //
       {52, 52},    //
   };
   std::vector<flutter::DlStrokeCap> caps = {
       flutter::DlStrokeCap::kButt,
       flutter::DlStrokeCap::kRound,
       flutter::DlStrokeCap::kSquare,
   };
   flutter::DlPaint paint =
       flutter::DlPaint()                                         //
           .setColor(flutter::DlColor::kYellow().withAlpha(127))  //
           .setStrokeWidth(20);
   builder.Translate(50, 50);
   for (auto cap : caps) {
     paint.setStrokeCap(cap);
     builder.Save();
     builder.DrawPoints(flutter::DlPointMode::kPoints, 7, points, paint);
     builder.Translate(150, 0);
     builder.DrawPoints(flutter::DlPointMode::kLines, 5, points, paint);
     builder.Translate(150, 0);
     builder.DrawPoints(flutter::DlPointMode::kPolygon, 5, points, paint);
     builder.Restore();
     builder.Translate(0, 150);
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References points.

◆ TEST_P() [358/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawRect
	)

Definition at line 46 of file dl_unittests.cc.

                                      {
   flutter::DisplayListBuilder builder;
   builder.DrawRect(DlRect::MakeXYWH(10, 10, 100, 100),
                    flutter::DlPaint(flutter::DlColor::kBlue()));
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [359/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawRectWithLinearToSrgbColorFilter
	)

Definition at line 1110 of file dl_unittests.cc.

                                                                 {
   flutter::DlPaint paint;
   paint.setColor(flutter::DlColor(0xFF2196F3).withAlpha(128));
   flutter::DisplayListBuilder builder;
   paint.setColorFilter(flutter::DlColorFilter::MakeLinearToSrgbGamma());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), paint);
   builder.Translate(0, 200);
  
   paint.setColorFilter(flutter::DlColorFilter::MakeSrgbToLinearGamma());
   builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [360/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawShadow
	)

Definition at line 866 of file dl_unittests.cc.

                                        {
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   auto content_scale = GetContentScale() * 0.8;
   builder.Scale(content_scale.x, content_scale.y);
  
   constexpr size_t star_spikes = 5;
   constexpr DlScalar half_spike_rotation = kPi / star_spikes;
   constexpr DlScalar radius = 40;
   constexpr DlScalar spike_size = 10;
   constexpr DlScalar outer_radius = radius + spike_size;
   constexpr DlScalar inner_radius = radius - spike_size;
   std::array<DlPoint, star_spikes * 2> star;
   for (size_t i = 0; i < star_spikes; i++) {
     const DlScalar rotation = half_spike_rotation * i * 2;
     star[i * 2] = DlPoint(50 + std::sin(rotation) * outer_radius,
                           50 - std::cos(rotation) * outer_radius);
     star[i * 2 + 1] =
         DlPoint(50 + std::sin(rotation + half_spike_rotation) * inner_radius,
                 50 - std::cos(rotation + half_spike_rotation) * inner_radius);
   }
  
   std::array<DlPath, 4> paths = {
       DlPath::MakeRect(DlRect::MakeXYWH(0, 0, 200, 100)),
       DlPath::MakeRoundRectXY(DlRect::MakeXYWH(20, 0, 200, 100), 30, 30),
       DlPath::MakeCircle(DlPoint(100, 50), 50),
       DlPath::MakePoly(star.data(), star.size(), true),
   };
   paint.setColor(flutter::DlColor::kWhite());
   builder.DrawPaint(paint);
   paint.setColor(flutter::DlColor::kCyan());
   builder.Translate(100, 50);
   for (size_t x = 0; x < paths.size(); x++) {
     builder.Save();
     for (size_t y = 0; y < 6; y++) {
       builder.DrawShadow(paths[x], flutter::DlColor::kBlack(), 3 + y * 8, false,
                          1);
       builder.DrawPath(paths[x], paint);
       builder.Translate(0, 150);
     }
     builder.Restore();
     builder.Translate(250, 0);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::kPi, and x.

◆ TEST_P() [361/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawStrokedText
	)

Definition at line 474 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() [362/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextBlob
	)

Definition at line 53 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() [363/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextBlobWithGradient
	)

Definition at line 60 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() [364/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextWithSaveLayer
	)

Definition at line 79 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(std::nullopt, &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() [365/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithBlendColorFilter
	)

Definition at line 526 of file dl_unittests.cc.

                                                      {
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   // Pipeline blended image.
   {
     auto filter = flutter::DlColorFilter::MakeBlend(
         flutter::DlColor::kYellow(), flutter::DlBlendMode::kModulate);
     paint.setColorFilter(filter);
     builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                       flutter::DlImageSampling::kNearestNeighbor, &paint);
   }
  
   // Advanced blended image.
   {
     auto filter = flutter::DlColorFilter::MakeBlend(
         flutter::DlColor::kRed(), flutter::DlBlendMode::kScreen);
     paint.setColorFilter(filter);
     builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(250, 250),
                       flutter::DlImageSampling::kNearestNeighbor, &paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [366/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithColorFilterImageFilter
	)

Definition at line 552 of file dl_unittests.cc.

                                                            {
   const float invert_color_matrix[20] = {
       -1, 0,  0,  0, 1,  //
       0,  -1, 0,  0, 1,  //
       0,  0,  -1, 0, 1,  //
       0,  0,  0,  1, 0,  //
   };
   auto texture = CreateTextureForFixture("boston.jpg");
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   auto color_filter = flutter::DlColorFilter::MakeMatrix(invert_color_matrix);
   auto image_filter = flutter::DlImageFilter::MakeColorFilter(color_filter);
  
   paint.setImageFilter(image_filter);
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor, &paint);
  
   builder.Translate(0, 700);
   paint.setColorFilter(color_filter);
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor, &paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [367/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithComposeImageFilter
	)

Definition at line 602 of file dl_unittests.cc.

                                                        {
   auto texture = CreateTextureForFixture("boston.jpg");
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   auto dilate = std::make_shared<flutter::DlDilateImageFilter>(10.0, 10.0);
   auto erode = std::make_shared<flutter::DlErodeImageFilter>(10.0, 10.0);
   auto open = std::make_shared<flutter::DlComposeImageFilter>(dilate, erode);
   auto close = std::make_shared<flutter::DlComposeImageFilter>(erode, dilate);
  
   paint.setImageFilter(open.get());
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor, &paint);
   builder.Translate(0, 700);
   paint.setImageFilter(close.get());
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor, &paint);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [368/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithImageBlurFilter
	)

Definition at line 577 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), DlPoint(200, 200),
                       flutter::DlImageSampling::kNearestNeighbor, &paint);
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [369/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMaskBlur
	)

Definition at line 438 of file dl_unittests.cc.

                                              {
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   // Mask blurred image.
   {
     auto filter =
         flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
     paint.setMaskFilter(&filter);
     builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                       flutter::DlImageSampling::kNearestNeighbor, &paint);
   }
  
   // Mask blurred filled path.
   {
     paint.setColor(flutter::DlColor::kYellow());
     auto filter =
         flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kOuter, 10.0f);
     paint.setMaskFilter(&filter);
     builder.DrawArc(DlRect::MakeXYWH(410, 110, 100, 100), 45, 270, true, paint);
   }
  
   // Mask blurred text.
   {
     auto filter =
         flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kSolid, 10.0f);
     paint.setMaskFilter(&filter);
     builder.DrawTextBlob(
         SkTextBlob::MakeFromString("Testing", CreateTestFont()), 220, 170,
         paint);
   }
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [370/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMatrixFilter
	)

Definition at line 948 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(std::nullopt, nullptr);
     }
     {
       auto content_scale = GetContentScale();
       builder.Scale(content_scale.x, content_scale.y);
  
       // Set the current transform
       auto ctm_matrix = Matrix::MakeRow(
           ctm_scale[0], ctm_skew[0], 0.0f, ctm_translation[0],  //
           ctm_skew[1], ctm_scale[1], 0.0f, ctm_translation[1],  //
           0, 0, 1, 0,                                           //
           0, 0, 0, 1);
       builder.Transform(ctm_matrix);
  
       // Set the matrix filter
       auto filter_matrix =
           Matrix::MakeRow(scale[0], skew[0], 0.0f, translation[0],  //
                           skew[1], scale[1], 0.0f, translation[1],  //
                           0.0f, 0.0f, 1.0f, 0.0f,                   //
                           0.0f, 0.0f, 0.0f, 1.0f);
  
       if (enable) {
         switch (selected_matrix_type) {
           case 0: {
             auto filter = flutter::DlMatrixImageFilter(
                 filter_matrix, flutter::DlImageSampling::kLinear);
             paint.setImageFilter(&filter);
             break;
           }
           case 1: {
             auto internal_filter =
                 flutter::DlBlurImageFilter(10, 10, flutter::DlTileMode::kDecal)
                     .shared();
             auto filter = flutter::DlLocalMatrixImageFilter(filter_matrix,
                                                             internal_filter);
             paint.setImageFilter(&filter);
             break;
           }
         }
       }
  
       builder.DrawImage(DlImageImpeller::Make(boston), DlPoint(),
                         flutter::DlImageSampling::kLinear, &paint);
     }
     if (enable_savelayer) {
       builder.Restore();
     }
  
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::DlImageImpeller::Make(), and impeller::Matrix::MakeRow().

◆ TEST_P() [371/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMatrixFilterWhenSavingLayer
	)

Definition at line 1053 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(DlRect::MakeWH(300, 300), paint);
     paint.setStrokeWidth(1.0);
     paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
     paint.setColor(flutter::DlColor::kBlack().withAlpha(0x80));
     builder.DrawLine(DlPoint(150, 0), DlPoint(150, 300), paint);
     builder.DrawLine(DlPoint(0, 150), DlPoint(300, 150), paint);
  
     flutter::DlPaint save_paint;
     DlRect bounds = DlRect::MakeXYWH(100, 100, 100, 100);
     Matrix translate_matrix =
         Matrix::MakeTranslation({translation[0], translation[1]});
     if (enable_save_layer) {
       auto filter = flutter::DlMatrixImageFilter(
           translate_matrix, flutter::DlImageSampling::kNearestNeighbor);
       save_paint.setImageFilter(filter.shared());
       builder.SaveLayer(bounds, &save_paint);
     } else {
       builder.Save();
       builder.Transform(translate_matrix);
     }
  
     Matrix filter_matrix;
     filter_matrix.Translate({150, 150});
     filter_matrix.Scale({0.2f, 0.2f});
     filter_matrix.Translate({-150, -150});
     auto filter = flutter::DlMatrixImageFilter(
         filter_matrix, flutter::DlImageSampling::kNearestNeighbor);
  
     save_paint.setImageFilter(filter.shared());
  
     builder.SaveLayer(bounds, &save_paint);
     flutter::DlPaint paint2;
     paint2.setColor(flutter::DlColor::kBlue());
     builder.DrawRect(bounds, paint2);
     builder.Restore();
     builder.Restore();
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Matrix::MakeTranslation(), impeller::Matrix::Scale(), and impeller::Matrix::Translate().

◆ TEST_P() [372/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithOddPathWinding
	)

Definition at line 394 of file dl_unittests.cc.

                                                    {
   flutter::DisplayListBuilder builder;
   flutter::DlPaint paint;
  
   paint.setColor(flutter::DlColor::kRed());
   paint.setDrawStyle(flutter::DlDrawStyle::kFill);
  
   builder.Translate(300, 300);
   flutter::DlPathBuilder path_builder;
   path_builder.AddCircle(DlPoint(0, 0), 100);
   path_builder.AddCircle(DlPoint(0, 0), 50);
   path_builder.SetFillType(flutter::DlPathFillType::kOdd);
   builder.DrawPath(path_builder.TakePath(), paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [373/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawZeroLengthLine
	)

Definition at line 843 of file dl_unittests.cc.

                                                {
   flutter::DisplayListBuilder builder;
   std::vector<flutter::DlStrokeCap> caps = {
       flutter::DlStrokeCap::kButt,
       flutter::DlStrokeCap::kRound,
       flutter::DlStrokeCap::kSquare,
   };
   flutter::DlPaint paint =
       flutter::DlPaint()                                         //
           .setColor(flutter::DlColor::kYellow().withAlpha(127))  //
           .setDrawStyle(flutter::DlDrawStyle::kStroke)           //
           .setStrokeCap(flutter::DlStrokeCap::kButt)             //
           .setStrokeWidth(20);
   DlPath path = DlPath::MakeLine({150, 50}, {150, 50});
   for (auto cap : caps) {
     paint.setStrokeCap(cap);
     builder.DrawLine(DlPoint(50, 50), DlPoint(50, 50), paint);
     builder.DrawPath(path, paint);
     builder.Translate(0, 150);
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [374/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawZeroWidthLine
	)

Definition at line 914 of file dl_unittests.cc.

                                               {
   flutter::DisplayListBuilder builder;
   std::vector<flutter::DlStrokeCap> caps = {
       flutter::DlStrokeCap::kButt,
       flutter::DlStrokeCap::kRound,
       flutter::DlStrokeCap::kSquare,
   };
   flutter::DlPaint paint =                              //
       flutter::DlPaint()                                //
           .setColor(flutter::DlColor::kWhite())         //
           .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
           .setStrokeWidth(0);
   flutter::DlPaint outline_paint =                      //
       flutter::DlPaint()                                //
           .setColor(flutter::DlColor::kYellow())        //
           .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
           .setStrokeCap(flutter::DlStrokeCap::kSquare)  //
           .setStrokeWidth(1);
   DlPath path = DlPath::MakeLine({150, 50}, {160, 50});
   for (auto cap : caps) {
     paint.setStrokeCap(cap);
     builder.DrawLine(DlPoint(50, 50), DlPoint(60, 50), paint);
     builder.DrawRect(DlRect::MakeLTRB(45, 45, 65, 55), outline_paint);
     builder.DrawLine(DlPoint{100, 50}, DlPoint{100, 50}, paint);
     if (cap != flutter::DlStrokeCap::kButt) {
       builder.DrawRect(DlRect::MakeLTRB(95, 45, 105, 55), outline_paint);
     }
     builder.DrawPath(path, paint);
     builder.DrawRect(path.GetBounds().Expand(5, 5), outline_paint);
     builder.Translate(0, 150);
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [375/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		ClipDrawRRectWithNonCircularRadii
	)

Definition at line 1343 of file dl_unittests.cc.

                                                            {
   flutter::DisplayListBuilder builder;
  
   flutter::DlPaint fill_paint =                       //
       flutter::DlPaint()                              //
           .setColor(flutter::DlColor::kBlue())        //
           .setDrawStyle(flutter::DlDrawStyle::kFill)  //
           .setStrokeWidth(10);
   flutter::DlPaint stroke_paint =                       //
       flutter::DlPaint()                                //
           .setColor(flutter::DlColor::kGreen())         //
           .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
           .setStrokeWidth(10);
  
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(500, 100, 300, 300), 120, 40),
       fill_paint);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(500, 100, 300, 300), 120, 40),
       stroke_paint);
  
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 500, 300, 300), 40, 120),
       fill_paint);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 500, 300, 300), 40, 120),
       stroke_paint);
  
   flutter::DlPaint reference_paint =                  //
       flutter::DlPaint()                              //
           .setColor(flutter::DlColor::kMidGrey())     //
           .setDrawStyle(flutter::DlDrawStyle::kFill)  //
           .setStrokeWidth(10);
  
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(500, 500, 300, 300), 40, 40),
       reference_paint);
   builder.DrawRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 100, 300, 300), 120, 120),
       reference_paint);
  
   flutter::DlPaint clip_fill_paint =                  //
       flutter::DlPaint()                              //
           .setColor(flutter::DlColor::kCyan())        //
           .setDrawStyle(flutter::DlDrawStyle::kFill)  //
           .setStrokeWidth(10);
  
   builder.Save();
   builder.ClipRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(900, 100, 300, 300), 120, 40));
   builder.DrawPaint(clip_fill_paint);
   builder.Restore();
  
   builder.Save();
   builder.ClipRoundRect(
       DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 900, 300, 300), 40, 120));
   builder.DrawPaint(clip_fill_paint);
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [376/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawMaskBlursThatMightUseSaveLayers
	)

Definition at line 1519 of file dl_unittests.cc.

                                                              {
   flutter::DisplayListBuilder builder;
   builder.DrawColor(flutter::DlColor::kWhite(), flutter::DlBlendMode::kSrc);
   Vector2 scale = GetContentScale();
   builder.Scale(scale.x, scale.y);
  
   builder.Save();
   // We need a small transform op to avoid a deferred save
   builder.Translate(1.0f, 1.0f);
   auto solid_filter =
       flutter::DlBlurMaskFilter::Make(flutter::DlBlurStyle::kSolid, 5.0f);
   flutter::DlPaint solid_alpha_paint =
       flutter::DlPaint()                        //
           .setMaskFilter(solid_filter)          //
           .setColor(flutter::DlColor::kBlue())  //
           .setAlpha(0x7f);
   for (int x = 1; x <= 4; x++) {
     for (int y = 1; y <= 4; y++) {
       builder.DrawRect(DlRect::MakeXYWH(x * 100, y * 100, 80, 80),
                        solid_alpha_paint);
     }
   }
   builder.Restore();
  
   builder.Save();
   builder.Translate(500.0f, 0.0f);
   auto normal_filter =
       flutter::DlBlurMaskFilter::Make(flutter::DlBlurStyle::kNormal, 5.0f);
   auto rotate_if = flutter::DlMatrixImageFilter::Make(
       Matrix::MakeRotationZ(Degrees(10)), flutter::DlImageSampling::kLinear);
   flutter::DlPaint normal_if_paint =
       flutter::DlPaint()                         //
           .setMaskFilter(solid_filter)           //
           .setImageFilter(rotate_if)             //
           .setColor(flutter::DlColor::kGreen())  //
           .setAlpha(0x7f);
   for (int x = 1; x <= 4; x++) {
     for (int y = 1; y <= 4; y++) {
       builder.DrawRect(DlRect::MakeXYWH(x * 100, y * 100, 80, 80),
                        normal_if_paint);
     }
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::Matrix::MakeRotationZ(), x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [377/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawPaintIgnoresMaskFilter
	)

Definition at line 1496 of file dl_unittests.cc.

                                                     {
   flutter::DisplayListBuilder builder;
   builder.DrawPaint(flutter::DlPaint().setColor(flutter::DlColor::kWhite()));
  
   auto filter = flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
   builder.DrawCircle(DlPoint(300, 300), 200,
                      flutter::DlPaint().setMaskFilter(&filter));
  
   std::vector<flutter::DlColor> colors = {flutter::DlColor::kGreen(),
                                           flutter::DlColor::kGreen()};
   const float stops[2] = {0.0, 1.0};
   auto linear = flutter::DlColorSource::MakeLinear(
       {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
       flutter::DlTileMode::kRepeat);
   flutter::DlPaint blend_paint =
       flutter::DlPaint()           //
           .setColorSource(linear)  //
           .setBlendMode(flutter::DlBlendMode::kScreen);
   builder.DrawPaint(blend_paint);
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [378/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawShapes
	)

Definition at line 1304 of file dl_unittests.cc.

                                     {
   flutter::DisplayListBuilder builder;
   std::vector<flutter::DlStrokeJoin> joins = {
       flutter::DlStrokeJoin::kBevel,
       flutter::DlStrokeJoin::kRound,
       flutter::DlStrokeJoin::kMiter,
   };
   flutter::DlPaint paint =                            //
       flutter::DlPaint()                              //
           .setColor(flutter::DlColor::kWhite())       //
           .setDrawStyle(flutter::DlDrawStyle::kFill)  //
           .setStrokeWidth(10);
   flutter::DlPaint stroke_paint =                       //
       flutter::DlPaint()                                //
           .setColor(flutter::DlColor::kWhite())         //
           .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
           .setStrokeWidth(10);
   DlPath path = DlPath::MakeLine({150, 50}, {160, 50});
  
   builder.Translate(300, 50);
   builder.Scale(0.8, 0.8);
   for (auto join : joins) {
     paint.setStrokeJoin(join);
     stroke_paint.setStrokeJoin(join);
     builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), paint);
     builder.DrawRect(DlRect::MakeXYWH(0, 150, 100, 100), stroke_paint);
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(150, 0, 100, 100), 30, 30),
         paint);
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(150, 150, 100, 100), 30, 30),
         stroke_paint);
     builder.DrawCircle(DlPoint(350, 50), 50, paint);
     builder.DrawCircle(DlPoint(350, 200), 50, stroke_paint);
     builder.Translate(0, 300);
   }
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

◆ TEST_P() [379/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawVerticesBlendModes
	)

Definition at line 1405 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<DlPoint> positions = {DlPoint(100, 300),  //
                                       DlPoint(200, 100),  //
                                       DlPoint(300, 300)};
     std::vector<flutter::DlColor> colors = {
         toColor(color0).modulateOpacity(dst_alpha),
         toColor(color1).modulateOpacity(dst_alpha),
         toColor(color2).modulateOpacity(dst_alpha)};
  
     auto vertices = flutter::DlVertices::Make(
         flutter::DlVertexMode::kTriangles, 3, positions.data(),
         /*texture_coordinates=*/nullptr, colors.data());
  
     flutter::DisplayListBuilder builder;
     flutter::DlPaint paint;
  
     paint.setColor(toColor(src_color).modulateOpacity(src_alpha));
     builder.DrawVertices(vertices, blend_mode_values[current_blend_index],
                          paint);
     return builder.Build();
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References toColor().

◆ TEST_P() [380/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		IgnoreMaskFilterWhenSavingLayer
	)

Definition at line 513 of file dl_unittests.cc.

                                                          {
   auto texture = CreateTextureForFixture("embarcadero.jpg");
   flutter::DisplayListBuilder builder;
   auto filter = flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
   flutter::DlPaint paint;
   paint.setMaskFilter(&filter);
   builder.SaveLayer(std::nullopt, &paint);
   builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                     flutter::DlImageSampling::kNearestNeighbor);
   builder.Restore();
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [381/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		MaskBlursApplyCorrectlyToColorSources
	)

Definition at line 1256 of file dl_unittests.cc.

                                                                {
   auto blur_filter = std::make_shared<flutter::DlBlurMaskFilter>(
       flutter::DlBlurStyle::kNormal, 10);
  
   flutter::DisplayListBuilder builder;
  
   std::array<flutter::DlColor, 2> colors = {flutter::DlColor::kBlue(),
                                             flutter::DlColor::kGreen()};
   std::array<float, 2> stops = {0, 1};
   auto texture = CreateTextureForFixture("airplane.jpg");
   auto matrix = flutter::DlMatrix::MakeTranslation({-300, -110});
   std::array<std::shared_ptr<flutter::DlColorSource>, 2> color_sources = {
       flutter::DlColorSource::MakeImage(
           DlImageImpeller::Make(texture), flutter::DlTileMode::kRepeat,
           flutter::DlTileMode::kRepeat, flutter::DlImageSampling::kLinear,
           &matrix),
       flutter::DlColorSource::MakeLinear(
           flutter::DlPoint(0, 0), flutter::DlPoint(100, 50), 2, colors.data(),
           stops.data(), flutter::DlTileMode::kClamp),
   };
  
   builder.Save();
   builder.Translate(0, 100);
   for (const auto& color_source : color_sources) {
     flutter::DlPaint paint;
     paint.setColorSource(color_source);
     paint.setMaskFilter(blur_filter);
  
     builder.Save();
     builder.Translate(100, 0);
     paint.setDrawStyle(flutter::DlDrawStyle::kFill);
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 30, 30), paint);
  
     paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
     paint.setStrokeWidth(10);
     builder.Translate(200, 0);
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 30, 30), paint);
  
     builder.Restore();
     builder.Translate(0, 100);
   }
   builder.Restore();
  
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [382/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		NinePatchImagePrecision
	)

Definition at line 796 of file dl_unittests.cc.

                                                  {
   // Draw a nine patch image with colored corners and verify that the corner
   // color does not leak outside the intended region.
   auto texture = CreateTextureForFixture("nine_patch_corners.png");
   flutter::DisplayListBuilder builder;
   builder.DrawImageNine(DlImageImpeller::Make(texture),
                         DlIRect::MakeXYWH(10, 10, 1, 1),
                         DlRect::MakeXYWH(0, 0, 200, 100),
                         flutter::DlFilterMode::kNearest, nullptr);
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }

References impeller::DlImageImpeller::Make().

◆ TEST_P() [383/545]

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(DlRect::MakeWH(100, 100), paint);
  
     // Rounded rectangle
     builder.Translate(150, 0);
     builder.DrawRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 10, 10), paint);
  
     // Double rounded rectangle
     builder.Translate(150, 0);
     builder.DrawDiffRoundRect(
         DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 10, 10),
         DlRoundRect::MakeRectXY(DlRect::MakeXYWH(10, 10, 80, 30), 10, 10),
         paint);
  
     // Contour with duplicate join points
     {
       builder.Translate(150, 0);
       flutter::DlPathBuilder path_builder;
       path_builder.MoveTo(DlPoint(0, 0));
       path_builder.LineTo(DlPoint(0, 0));
       path_builder.LineTo(DlPoint(100, 0));
       path_builder.LineTo(DlPoint(100, 0));
       path_builder.LineTo(DlPoint(100, 100));
       builder.DrawPath(path_builder.TakePath(), paint);
     }
  
     // Contour with duplicate start and end points
  
     // Line.
     builder.Translate(200, 0);
     {
       builder.Save();
  
       flutter::DlPathBuilder line_path_builder;
       line_path_builder.MoveTo(DlPoint(0, 0));
       line_path_builder.MoveTo(DlPoint(0, 0));
       line_path_builder.LineTo(DlPoint(0, 0));
       line_path_builder.LineTo(DlPoint(0, 0));
       line_path_builder.LineTo(DlPoint(50, 50));
       line_path_builder.LineTo(DlPoint(50, 50));
       line_path_builder.LineTo(DlPoint(100, 0));
       line_path_builder.LineTo(DlPoint(100, 0));
       DlPath line_path = line_path_builder.TakePath();
       builder.DrawPath(line_path, paint);
  
       builder.Translate(0, 100);
       builder.DrawPath(line_path, paint);
  
       builder.Translate(0, 100);
       flutter::DlPathBuilder line_path_builder2;
       line_path_builder2.MoveTo(DlPoint(0, 0));
       line_path_builder2.LineTo(DlPoint(0, 0));
       line_path_builder2.LineTo(DlPoint(0, 0));
       builder.DrawPath(line_path_builder2.TakePath(), paint);
  
       builder.Restore();
     }
  
     // Cubic.
     builder.Translate(150, 0);
     {
       builder.Save();
  
       flutter::DlPathBuilder cubic_path;
       cubic_path.MoveTo(DlPoint(0, 0));
       cubic_path.CubicCurveTo(DlPoint(0, 0),          //
                               DlPoint(140.0, 100.0),  //
                               DlPoint(140, 20));
       builder.DrawPath(cubic_path.TakePath(), paint);
  
       builder.Translate(0, 100);
       flutter::DlPathBuilder cubic_path2;
       cubic_path2.MoveTo(DlPoint(0, 0));
       cubic_path2.CubicCurveTo(DlPoint(0, 0),  //
                                DlPoint(0, 0),  //
                                DlPoint(150, 150));
       builder.DrawPath(cubic_path2.TakePath(), paint);
  
       builder.Translate(0, 100);
       flutter::DlPathBuilder cubic_path3;
       cubic_path3.MoveTo(DlPoint(0, 0));
       cubic_path3.CubicCurveTo(DlPoint(0, 0),  //
                                DlPoint(0, 0),  //
                                DlPoint(0, 0));
       builder.DrawPath(cubic_path3.TakePath(), paint);
  
       builder.Restore();
     }
  
     // Quad.
     builder.Translate(200, 0);
     {
       builder.Save();
  
       flutter::DlPathBuilder quad_path;
       quad_path.MoveTo(DlPoint(0, 0));
       quad_path.MoveTo(DlPoint(0, 0));
       quad_path.QuadraticCurveTo(DlPoint(100, 40), DlPoint(50, 80));
       builder.DrawPath(quad_path.TakePath(), paint);
  
       builder.Translate(0, 150);
       flutter::DlPathBuilder quad_path2;
       quad_path2.MoveTo(DlPoint(0, 0));
       quad_path2.MoveTo(DlPoint(0, 0));
       quad_path2.QuadraticCurveTo(DlPoint(0, 0), DlPoint(100, 100));
       builder.DrawPath(quad_path2.TakePath(), paint);
  
       builder.Translate(0, 100);
       flutter::DlPathBuilder quad_path3;
       quad_path3.MoveTo(DlPoint(0, 0));
       quad_path3.QuadraticCurveTo(DlPoint(0, 0), DlPoint(0, 0));
       builder.DrawPath(quad_path3.TakePath(), paint);
  
       builder.Restore();
     }
     return builder.Build();
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

◆ TEST_P() [384/545]

impeller::testing::TEST_P	(	DisplayListTest	,
		StrokedTextNotOffsetFromNormalText
	)

Definition at line 488 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(DlRect::MakeXYWH(0, 0, 500, 500), paint);
  
   // Draw stacked text, with stroked text on top.
   paint.setDrawStyle(flutter::DlDrawStyle::kFill);
   paint.setColor(flutter::DlColor::kWhite());
   builder.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() [385/545]

impeller::testing::TEST_P	(	DriverInfoVKTest	,
		CanDumpToLog
	)

Definition at line 30 of file driver_info_vk_unittests.cc.

                                        {
   ASSERT_TRUE(GetContext());
   const auto& driver_info =
       SurfaceContextVK::Cast(*GetContext()).GetParent()->GetDriverInfo();
   ASSERT_NE(driver_info, nullptr);
   fml::testing::LogCapture log;
   driver_info->DumpToLog();
   EXPECT_TRUE(log.str().find("Driver Information") != std::string::npos);
 }

References impeller::BackendCast< SurfaceContextVK, Context >::Cast(), and impeller::SurfaceContextVK::GetParent().

◆ TEST_P() [386/545]

impeller::testing::TEST_P	(	DriverInfoVKTest	,
		CanQueryDriverInfo
	)

Definition at line 17 of file driver_info_vk_unittests.cc.

                                              {
   ASSERT_TRUE(GetContext());
   const auto& driver_info =
       SurfaceContextVK::Cast(*GetContext()).GetParent()->GetDriverInfo();
   ASSERT_NE(driver_info, nullptr);
   // 1.1 is the base Impeller version. The driver can't be lower than that.
   ASSERT_TRUE(driver_info->GetAPIVersion().IsAtLeast(Version{1, 1, 0}));
   ASSERT_NE(driver_info->GetVendor(), VendorVK::kUnknown);
   ASSERT_NE(driver_info->GetDeviceType(), DeviceTypeVK::kUnknown);
   ASSERT_NE(driver_info->GetDriverName(), "");
   EXPECT_FALSE(driver_info->IsKnownBadDriver());
 }

References impeller::BackendCast< SurfaceContextVK, Context >::Cast(), impeller::SurfaceContextVK::GetParent(), and impeller::kUnknown.

◆ TEST_P() [387/545]

impeller::testing::TEST_P	(	EntityPassTargetTest	,
		SwapWithMSAAImplicitResolve
	)

Definition at line 47 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().GetColorAttachment(0);
   auto msaa_tex = color0.texture;
   auto resolve_tex = color0.resolve_texture;
  
   ASSERT_EQ(msaa_tex, resolve_tex);
  
   FML_DCHECK(content_context);
   entity_pass_target.Flip(*content_context);
  
   color0 = entity_pass_target.GetRenderTarget().GetColorAttachment(0);
  
   ASSERT_NE(msaa_tex, color0.texture);
   ASSERT_NE(resolve_tex, color0.resolve_texture);
   ASSERT_EQ(color0.texture, color0.resolve_texture);
 }

References impeller::TextureDescriptor::format, impeller::kCount4, impeller::kDevicePrivate, impeller::kDontCare, impeller::kRenderTarget, impeller::kStoreAndMultisampleResolve, impeller::kTexture2DMultisample, impeller::Attachment::load_action, impeller::Attachment::resolve_texture, impeller::TextureDescriptor::sample_count, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetStencilAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, impeller::TextureDescriptor::type, and impeller::TextureDescriptor::usage.

◆ TEST_P() [388/545]

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().GetColorAttachment(0);
   auto msaa_tex = color0.texture;
   auto resolve_tex = color0.resolve_texture;
  
   FML_DCHECK(content_context);
   entity_pass_target.Flip(*content_context);
  
   color0 = entity_pass_target.GetRenderTarget().GetColorAttachment(0);
  
   ASSERT_EQ(msaa_tex, color0.texture);
   ASSERT_NE(resolve_tex, color0.resolve_texture);
 }

◆ TEST_P() [389/545]

impeller::testing::TEST_P	(	EntityTest	,
		BezierCircleScaled
	)

Definition at line 878 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 = flutter::DlPathBuilder{}
                     .MoveTo({97.325, 34.818})
                     .CubicCurveTo({98.50862885295136, 34.81812293973836},
                                   {99.46822048142015, 33.85863261475589},
                                   {99.46822048142015, 32.67499810206613})
                     .CubicCurveTo({99.46822048142015, 31.491363589376355},
                                   {98.50862885295136, 30.53187326439389},
                                   {97.32499434685802, 30.531998226542708})
                     .CubicCurveTo({96.14153655073771, 30.532123170035373},
                                   {95.18222070648729, 31.491540299350355},
                                   {95.18222070648729, 32.67499810206613})
                     .CubicCurveTo({95.18222070648729, 33.85845590478189},
                                   {96.14153655073771, 34.81787303409686},
                                   {97.32499434685802, 34.81799797758954})
                     .Close()
                     .TakePath();
     entity.SetTransform(
         Matrix::MakeScale({scale, scale, 1.0}).Translate({-90, -20, 0}));
  
     std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
  
     auto contents = std::make_shared<SolidColorContents>();
     contents->SetColor(Color::Red());
     contents->SetGeometry(geom.get());
  
     entity.SetContents(contents);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Close(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [390/545]

impeller::testing::TEST_P	(	EntityTest	,
		BlendingModeOptions
	)

Definition at line 747 of file entity_unittests.cc.

                                         {
   std::vector<const char*> blend_mode_names;
   std::vector<BlendMode> blend_mode_values;
   {
     // Force an exhausiveness check with a switch. When adding blend modes,
     // update this switch with a new name/value to make it selectable in the
     // test GUI.
  
     const BlendMode b{};
     static_assert(b == BlendMode::kClear);  // Ensure the first item in
                                             // the switch is the first
                                             // item in the enum.
     static_assert(Entity::kLastPipelineBlendMode == BlendMode::kModulate);
     switch (b) {
       case BlendMode::kClear:
         blend_mode_names.push_back("Clear");
         blend_mode_values.push_back(BlendMode::kClear);
       case BlendMode::kSrc:
         blend_mode_names.push_back("Source");
         blend_mode_values.push_back(BlendMode::kSrc);
       case BlendMode::kDst:
         blend_mode_names.push_back("Destination");
         blend_mode_values.push_back(BlendMode::kDst);
       case BlendMode::kSrcOver:
         blend_mode_names.push_back("SourceOver");
         blend_mode_values.push_back(BlendMode::kSrcOver);
       case BlendMode::kDstOver:
         blend_mode_names.push_back("DestinationOver");
         blend_mode_values.push_back(BlendMode::kDstOver);
       case BlendMode::kSrcIn:
         blend_mode_names.push_back("SourceIn");
         blend_mode_values.push_back(BlendMode::kSrcIn);
       case BlendMode::kDstIn:
         blend_mode_names.push_back("DestinationIn");
         blend_mode_values.push_back(BlendMode::kDstIn);
       case BlendMode::kSrcOut:
         blend_mode_names.push_back("SourceOut");
         blend_mode_values.push_back(BlendMode::kSrcOut);
       case BlendMode::kDstOut:
         blend_mode_names.push_back("DestinationOut");
         blend_mode_values.push_back(BlendMode::kDstOut);
       case BlendMode::kSrcATop:
         blend_mode_names.push_back("SourceATop");
         blend_mode_values.push_back(BlendMode::kSrcATop);
       case BlendMode::kDstATop:
         blend_mode_names.push_back("DestinationATop");
         blend_mode_values.push_back(BlendMode::kDstATop);
       case BlendMode::kXor:
         blend_mode_names.push_back("Xor");
         blend_mode_values.push_back(BlendMode::kXor);
       case BlendMode::kPlus:
         blend_mode_names.push_back("Plus");
         blend_mode_values.push_back(BlendMode::kPlus);
       case BlendMode::kModulate:
         blend_mode_names.push_back("Modulate");
         blend_mode_values.push_back(BlendMode::kModulate);
     };
   }
  
   auto callback = [&](ContentContext& context, RenderPass& pass) {
     auto world_matrix = Matrix::MakeScale(GetContentScale());
     auto draw_rect = [&context, &pass, &world_matrix](
                          Rect rect, Color color, BlendMode blend_mode) -> bool {
       using VS = SolidFillPipeline::VertexShader;
       using FS = SolidFillPipeline::FragmentShader;
  
       VertexBufferBuilder<VS::PerVertexData> vtx_builder;
       {
         auto r = rect.GetLTRB();
         vtx_builder.AddVertices({
             {Point(r[0], r[1])},
             {Point(r[2], r[1])},
             {Point(r[2], r[3])},
             {Point(r[0], r[1])},
             {Point(r[2], r[3])},
             {Point(r[0], r[3])},
         });
       }
  
       pass.SetCommandLabel("Blended Rectangle");
       auto options = OptionsFromPass(pass);
       options.blend_mode = blend_mode;
       options.primitive_type = PrimitiveType::kTriangle;
       pass.SetPipeline(context.GetSolidFillPipeline(options));
       pass.SetVertexBuffer(
           vtx_builder.CreateVertexBuffer(context.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::kSrcOver);
     result = result && draw_rect(Rect::MakeLTRB(c.x, c.y, d.x, d.y), color2,
                                  selected_mode);
     return result;
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::saturated::b, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::DrawPlaygroundLine(), impeller::HostBuffer::EmplaceUniform(), impeller::ContentContext::GetSolidFillPipeline(), impeller::ContentContext::GetTransientsBuffer(), impeller::kClear, impeller::kDst, impeller::kDstATop, impeller::kDstIn, impeller::kDstOut, impeller::kDstOver, impeller::Entity::kLastPipelineBlendMode, impeller::kModulate, impeller::kPlus, impeller::kSrc, impeller::kSrcATop, impeller::kSrcIn, impeller::kSrcOut, impeller::kSrcOver, impeller::kTriangle, impeller::kXor, impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), impeller::OptionsFromPass(), impeller::Color::White(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [391/545]

impeller::testing::TEST_P	(	EntityTest	,
		BorderMaskBlurCoverageIsCorrect
	)

Definition at line 1319 of file entity_unittests.cc.

                                                     {
   auto fill = std::make_shared<SolidColorContents>();
   auto geom = Geometry::MakeFillPath(
       flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
   fill->SetGeometry(geom.get());
   fill->SetColor(Color::CornflowerBlue());
   auto border_mask_blur = FilterContents::MakeBorderMaskBlur(
       FilterInput::Make(fill), Radius{3}, Radius{4});
  
   {
     Entity e;
     e.SetTransform(Matrix());
     auto actual = border_mask_blur->GetCoverage(e);
     auto expected = Rect::MakeXYWH(-3, -4, 306, 408);
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
  
   {
     Entity e;
     e.SetTransform(Matrix::MakeRotationZ(Radians{kPi / 4}));
     auto actual = border_mask_blur->GetCoverage(e);
     auto expected = Rect::MakeXYWH(-287.792, -4.94975, 504.874, 504.874);
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
 }

References ASSERT_RECT_NEAR, impeller::Color::CornflowerBlue(), impeller::kPi, impeller::FilterInput::Make(), impeller::FilterContents::MakeBorderMaskBlur(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeRotationZ(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Entity::SetTransform().

◆ TEST_P() [392/545]

impeller::testing::TEST_P	(	EntityTest	,
		CanComputeGeometryForEmptyPathsWithoutCrashing
	)

Definition at line 2314 of file entity_unittests.cc.

                                                                    {
   flutter::DlPath path = flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 0, 0));
  
   EXPECT_TRUE(path.GetBounds().IsEmpty());
  
   auto geom = Geometry::MakeFillPath(path);
  
   Entity entity;
   RenderTarget target =
       GetContentContext()->GetRenderTargetCache()->CreateOffscreen(
           *GetContext(), {1, 1}, 1u);
   testing::MockRenderPass render_pass(GetContext(), target);
   auto position_result =
       geom->GetPositionBuffer(*GetContentContext(), entity, render_pass);
  
   EXPECT_EQ(position_result.vertex_buffer.vertex_count, 0u);
  
   EXPECT_EQ(geom->GetResultMode(), GeometryResult::Mode::kNormal);
 }

References impeller::GeometryResult::kNormal, impeller::Geometry::MakeFillPath(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST_P() [393/545]

impeller::testing::TEST_P	(	EntityTest	,
		CanCreateEntity
	)

Definition at line 72 of file entity_unittests.cc.

                                     {
   Entity entity;
   ASSERT_TRUE(entity.GetTransform().IsIdentity());
 }

References impeller::Entity::GetTransform(), and impeller::Matrix::IsIdentity().

◆ TEST_P() [394/545]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawCorrectlyWithRotatedTransform
	)

Definition at line 399 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;
     flutter::DlPath path =
         flutter::DlPath::MakeRect(Rect::MakeXYWH(-300, -400, 600, 800));
  
     Entity entity;
     entity.SetTransform(result_transform);
  
     std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
  
     auto contents = std::make_shared<SolidColorContents>();
     contents->SetColor(Color::Red());
     contents->SetGeometry(geom.get());
  
     entity.SetContents(contents);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kPi, impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [395/545]

impeller::testing::TEST_P	(	EntityTest	,
		CanRenderEmptyPathsWithoutCrashing
	)

Definition at line 2334 of file entity_unittests.cc.

                                                        {
   flutter::DlPath path = flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 0, 0));
  
   EXPECT_TRUE(path.GetBounds().IsEmpty());
  
   auto contents = std::make_shared<SolidColorContents>();
   std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
   contents->SetGeometry(geom.get());
   contents->SetColor(Color::Red());
  
   Entity entity;
   entity.SetTransform(Matrix::MakeScale(GetContentScale()));
   entity.SetContents(contents);
  
   ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
 }

References impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [396/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterContentsWithLargeGeometry
	)

Definition at line 2158 of file entity_unittests.cc.

                                                          {
   Entity entity;
   entity.SetTransform(Matrix::MakeScale(GetContentScale()));
   auto src_contents = std::make_shared<SolidColorContents>();
   auto src_geom = Geometry::MakeRect(Rect::MakeLTRB(-300, -500, 30000, 50000));
   src_contents->SetGeometry(src_geom.get());
   src_contents->SetColor(Color::Red());
  
   auto dst_contents = std::make_shared<SolidColorContents>();
   auto dst_geom = Geometry::MakeRect(Rect::MakeLTRB(300, 500, 20000, 30000));
   dst_contents->SetGeometry(dst_geom.get());
   dst_contents->SetColor(Color::Blue());
  
   auto contents = ColorFilterContents::MakeBlend(
       BlendMode::kSrcOver, {FilterInput::Make(dst_contents, false),
                             FilterInput::Make(src_contents, false)});
   entity.SetContents(std::move(contents));
   ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
 }

References impeller::Color::Blue(), impeller::kSrcOver, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Matrix::MakeScale(), impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [397/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorAdvancedBlend
	)

Definition at line 1921 of file entity_unittests.cc.

                                                                 {
   auto image = CreateTextureForFixture("boston.jpg");
   auto filter = ColorFilterContents::MakeBlend(
       BlendMode::kColorBurn, FilterInput::Make({image}), Color::Red());
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                         Matrix::MakeTranslation({500, 300}) *
                         Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity.SetContents(filter);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kColorBurn, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [398/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorClearBlend
	)

Definition at line 1937 of file entity_unittests.cc.

                                                              {
   auto image = CreateTextureForFixture("boston.jpg");
   auto filter = ColorFilterContents::MakeBlend(
       BlendMode::kClear, FilterInput::Make({image}), Color::Red());
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                         Matrix::MakeTranslation({500, 300}) *
                         Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity.SetContents(filter);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kClear, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [399/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorDstBlend
	)

Definition at line 1969 of file entity_unittests.cc.

                                                            {
   auto image = CreateTextureForFixture("boston.jpg");
   auto filter = ColorFilterContents::MakeBlend(
       BlendMode::kDst, FilterInput::Make({image}), Color::Red());
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                         Matrix::MakeTranslation({500, 300}) *
                         Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity.SetContents(filter);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kDst, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [400/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorSrcBlend
	)

Definition at line 1953 of file entity_unittests.cc.

                                                            {
   auto image = CreateTextureForFixture("boston.jpg");
   auto filter = ColorFilterContents::MakeBlend(
       BlendMode::kSrc, FilterInput::Make({image}), Color::Red());
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                         Matrix::MakeTranslation({500, 300}) *
                         Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity.SetContents(filter);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kSrc, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [401/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorSrcInBlend
	)

Definition at line 1985 of file entity_unittests.cc.

                                                              {
   auto image = CreateTextureForFixture("boston.jpg");
   auto filter = ColorFilterContents::MakeBlend(
       BlendMode::kSrcIn, FilterInput::Make({image}), Color::Red());
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                         Matrix::MakeTranslation({500, 300}) *
                         Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity.SetContents(filter);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kSrcIn, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [402/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorMatrixFilterCoverageIsCorrect
	)

Definition at line 1446 of file entity_unittests.cc.

                                                        {
   // Set up a simple color background.
   auto fill = std::make_shared<SolidColorContents>();
   auto geom = Geometry::MakeFillPath(
       flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
   fill->SetGeometry(geom.get());
   fill->SetColor(Color::Coral());
  
   // Set the color matrix filter.
   ColorMatrix matrix = {
       1, 1, 1, 1, 1,  //
       1, 1, 1, 1, 1,  //
       1, 1, 1, 1, 1,  //
       1, 1, 1, 1, 1,  //
   };
  
   auto filter =
       ColorFilterContents::MakeColorMatrix(FilterInput::Make(fill), matrix);
  
   Entity e;
   e.SetTransform(Matrix());
  
   // Confirm that the actual filter coverage matches the expected coverage.
   auto actual = filter->GetCoverage(e);
   auto expected = Rect::MakeXYWH(0, 0, 300, 400);
  
   ASSERT_TRUE(actual.has_value());
   ASSERT_RECT_NEAR(actual.value(), expected);
 }

References ASSERT_RECT_NEAR, impeller::Color::Coral(), impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeColorMatrix(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Entity::SetTransform().

◆ TEST_P() [403/545]

impeller::testing::TEST_P	(	EntityTest	,
		ColorMatrixFilterEditable
	)

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

References impeller::ColorMatrix::array, impeller::kPi, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeColorMatrix(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeSkew(), impeller::Matrix::MakeTranslation(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [404/545]

impeller::testing::TEST_P	(	EntityTest	,
		ConicalGradientContentsIsOpaque
	)

Definition at line 2046 of file entity_unittests.cc.

                                                     {
   Matrix matrix;
   ConicalGradientContents contents;
   auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
   contents.SetGeometry(geom.get());
  
   contents.SetColors({Color::CornflowerBlue()});
   EXPECT_FALSE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
   EXPECT_FALSE(contents.IsOpaque(matrix));
  
   // Create stroked path that required alpha coverage.
   geom = Geometry::MakeStrokePath(
       flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
       {.width = 0.05f});
   contents.SetGeometry(geom.get());
   contents.SetColors({Color::CornflowerBlue()});
  
   EXPECT_FALSE(contents.IsOpaque(matrix));
 }

References impeller::Color::CornflowerBlue(), impeller::Contents::IsOpaque(), impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), impeller::ConicalGradientContents::SetColors(), impeller::ColorSourceContents::SetGeometry(), and impeller::Color::WithAlpha().

◆ TEST_P() [405/545]

impeller::testing::TEST_P	(	EntityTest	,
		ContentContextOptionsHasReasonableHashFunctions
	)

Definition at line 2225 of file entity_unittests.cc.

                                                                     {
   ContentContextOptions opts;
   auto hash_a = opts.ToKey();
  
   opts.blend_mode = BlendMode::kColorBurn;
   auto hash_b = opts.ToKey();
  
   opts.has_depth_stencil_attachments = false;
   auto hash_c = opts.ToKey();
  
   opts.primitive_type = PrimitiveType::kPoint;
   auto hash_d = opts.ToKey();
  
   EXPECT_NE(hash_a, hash_b);
   EXPECT_NE(hash_b, hash_c);
   EXPECT_NE(hash_c, hash_d);
 }

References impeller::ContentContextOptions::blend_mode, impeller::ContentContextOptions::has_depth_stencil_attachments, impeller::kColorBurn, impeller::kPoint, impeller::ContentContextOptions::primitive_type, and impeller::ContentContextOptions::ToKey().

◆ TEST_P() [406/545]

impeller::testing::TEST_P	(	EntityTest	,
		ContentsGetBoundsForEmptyPathReturnsNullopt
	)

Definition at line 1242 of file entity_unittests.cc.

                                                                 {
   Entity entity;
   entity.SetContents(std::make_shared<SolidColorContents>());
   ASSERT_FALSE(entity.GetCoverage().has_value());
 }

References impeller::Entity::GetCoverage(), and impeller::Entity::SetContents().

◆ TEST_P() [407/545]

impeller::testing::TEST_P	(	EntityTest	,
		CoverageForStrokePathWithNegativeValuesInTransform
	)

Definition at line 2001 of file entity_unittests.cc.

                                                                        {
   auto arrow_head = flutter::DlPathBuilder{}
                         .MoveTo({50, 120})
                         .LineTo({120, 190})
                         .LineTo({190, 120})
                         .TakePath();
   auto geometry = Geometry::MakeStrokePath(arrow_head,  //
                                            {
                                                .width = 15.0f,
                                                .cap = Cap::kRound,
                                                .join = Join::kRound,
                                                .miter_limit = 4.0f,
                                            });
  
   auto transform = Matrix::MakeTranslation({300, 300}) *
                    Matrix::MakeRotationZ(Radians(kPiOver2));
   // Note that e[0][0] used to be tested here, but it was -epsilon solely
   // due to floating point inaccuracy in the transcendental trig functions.
   // e[1][0] is the intended negative value that we care about (-1.0) as it
   // comes from the rotation of pi/2.
   EXPECT_LT(transform.e[1][0], 0.0f);
   auto coverage = geometry->GetCoverage(transform);
   ASSERT_RECT_NEAR(coverage.value(), Rect::MakeXYWH(102.5, 342.5, 85, 155));
 }

References ASSERT_RECT_NEAR, impeller::kPiOver2, impeller::kRound, impeller::LineTo(), impeller::Matrix::MakeRotationZ(), impeller::Geometry::MakeStrokePath(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST_P() [408/545]

impeller::testing::TEST_P	(	EntityTest	,
		CubicCurveAndOverlapTest
	)

Definition at line 452 of file entity_unittests.cc.

                                              {
   // Compare with https://fiddle.skia.org/c/7a05a3e186c65a8dfb732f68020aae06
   flutter::DlPath path =
       flutter::DlPathBuilder{}
           .MoveTo({359.934, 96.6335})
           .CubicCurveTo({358.189, 96.7055}, {356.436, 96.7908},
                         {354.673, 96.8895})
           .CubicCurveTo({354.571, 96.8953}, {354.469, 96.9016},
                         {354.367, 96.9075})
           .CubicCurveTo({352.672, 97.0038}, {350.969, 97.113},
                         {349.259, 97.2355})
           .CubicCurveTo({349.048, 97.2506}, {348.836, 97.2678},
                         {348.625, 97.2834})
           .CubicCurveTo({347.019, 97.4014}, {345.407, 97.5299},
                         {343.789, 97.6722})
           .CubicCurveTo({343.428, 97.704}, {343.065, 97.7402},
                         {342.703, 97.7734})
           .CubicCurveTo({341.221, 97.9086}, {339.736, 98.0505},
                         {338.246, 98.207})
           .CubicCurveTo({337.702, 98.2642}, {337.156, 98.3292},
                         {336.612, 98.3894})
           .CubicCurveTo({335.284, 98.5356}, {333.956, 98.6837},
                         {332.623, 98.8476})
           .CubicCurveTo({332.495, 98.8635}, {332.366, 98.8818},
                         {332.237, 98.8982})
           .LineTo({332.237, 102.601})
           .LineTo({321.778, 102.601})
           .LineTo({321.778, 100.382})
           .CubicCurveTo({321.572, 100.413}, {321.367, 100.442},
                         {321.161, 100.476})
           .CubicCurveTo({319.22, 100.79}, {317.277, 101.123},
                         {315.332, 101.479})
           .CubicCurveTo({315.322, 101.481}, {315.311, 101.482},
                         {315.301, 101.484})
           .LineTo({310.017, 105.94})
           .LineTo({309.779, 105.427})
           .LineTo({314.403, 101.651})
           .CubicCurveTo({314.391, 101.653}, {314.379, 101.656},
                         {314.368, 101.658})
           .CubicCurveTo({312.528, 102.001}, {310.687, 102.366},
                         {308.846, 102.748})
           .CubicCurveTo({307.85, 102.955}, {306.855, 103.182}, {305.859, 103.4})
           .CubicCurveTo({305.048, 103.579}, {304.236, 103.75},
                         {303.425, 103.936})
           .LineTo({299.105, 107.578})
           .LineTo({298.867, 107.065})
           .LineTo({302.394, 104.185})
           .LineTo({302.412, 104.171})
           .CubicCurveTo({301.388, 104.409}, {300.366, 104.67},
                         {299.344, 104.921})
           .CubicCurveTo({298.618, 105.1}, {297.89, 105.269}, {297.165, 105.455})
           .CubicCurveTo({295.262, 105.94}, {293.36, 106.445},
                         {291.462, 106.979})
           .CubicCurveTo({291.132, 107.072}, {290.802, 107.163},
                         {290.471, 107.257})
           .CubicCurveTo({289.463, 107.544}, {288.455, 107.839},
                         {287.449, 108.139})
           .CubicCurveTo({286.476, 108.431}, {285.506, 108.73},
                         {284.536, 109.035})
           .CubicCurveTo({283.674, 109.304}, {282.812, 109.579},
                         {281.952, 109.859})
           .CubicCurveTo({281.177, 110.112}, {280.406, 110.377},
                         {279.633, 110.638})
           .CubicCurveTo({278.458, 111.037}, {277.256, 111.449},
                         {276.803, 111.607})
           .CubicCurveTo({276.76, 111.622}, {276.716, 111.637},
                         {276.672, 111.653})
           .CubicCurveTo({275.017, 112.239}, {273.365, 112.836},
                         {271.721, 113.463})
           .LineTo({271.717, 113.449})
           .CubicCurveTo({271.496, 113.496}, {271.238, 113.559},
                         {270.963, 113.628})
           .CubicCurveTo({270.893, 113.645}, {270.822, 113.663},
                         {270.748, 113.682})
           .CubicCurveTo({270.468, 113.755}, {270.169, 113.834},
                         {269.839, 113.926})
           .CubicCurveTo({269.789, 113.94}, {269.732, 113.957},
                         {269.681, 113.972})
           .CubicCurveTo({269.391, 114.053}, {269.081, 114.143},
                         {268.756, 114.239})
           .CubicCurveTo({268.628, 114.276}, {268.5, 114.314},
                         {268.367, 114.354})
           .CubicCurveTo({268.172, 114.412}, {267.959, 114.478},
                         {267.752, 114.54})
           .CubicCurveTo({263.349, 115.964}, {258.058, 117.695},
                         {253.564, 119.252})
           .CubicCurveTo({253.556, 119.255}, {253.547, 119.258},
                         {253.538, 119.261})
           .CubicCurveTo({251.844, 119.849}, {250.056, 120.474},
                         {248.189, 121.131})
           .CubicCurveTo({248, 121.197}, {247.812, 121.264}, {247.621, 121.331})
           .CubicCurveTo({247.079, 121.522}, {246.531, 121.715},
                         {245.975, 121.912})
           .CubicCurveTo({245.554, 122.06}, {245.126, 122.212},
                         {244.698, 122.364})
           .CubicCurveTo({244.071, 122.586}, {243.437, 122.811},
                         {242.794, 123.04})
           .CubicCurveTo({242.189, 123.255}, {241.58, 123.472},
                         {240.961, 123.693})
           .CubicCurveTo({240.659, 123.801}, {240.357, 123.909},
                         {240.052, 124.018})
           .CubicCurveTo({239.12, 124.351}, {238.18, 124.687}, {237.22, 125.032})
           .LineTo({237.164, 125.003})
           .CubicCurveTo({236.709, 125.184}, {236.262, 125.358},
                         {235.81, 125.538})
           .CubicCurveTo({235.413, 125.68}, {234.994, 125.832},
                         {234.592, 125.977})
           .CubicCurveTo({234.592, 125.977}, {234.591, 125.977},
                         {234.59, 125.977})
           .CubicCurveTo({222.206, 130.435}, {207.708, 135.753},
                         {192.381, 141.429})
           .CubicCurveTo({162.77, 151.336}, {122.17, 156.894}, {84.1123, 160})
           .LineTo({360, 160})
           .LineTo({360, 119.256})
           .LineTo({360, 106.332})
           .LineTo({360, 96.6307})
           .CubicCurveTo({359.978, 96.6317}, {359.956, 96.6326},
                         {359.934, 96.6335})
           .Close()
           .MoveTo({337.336, 124.143})
           .CubicCurveTo({337.274, 122.359}, {338.903, 121.511},
                         {338.903, 121.511})
           .CubicCurveTo({338.903, 121.511}, {338.96, 123.303},
                         {337.336, 124.143})
           .Close()
           .MoveTo({340.082, 121.849})
           .CubicCurveTo({340.074, 121.917}, {340.062, 121.992},
                         {340.046, 122.075})
           .CubicCurveTo({340.039, 122.109}, {340.031, 122.142},
                         {340.023, 122.177})
           .CubicCurveTo({340.005, 122.26}, {339.98, 122.346},
                         {339.952, 122.437})
           .CubicCurveTo({339.941, 122.473}, {339.931, 122.507},
                         {339.918, 122.544})
           .CubicCurveTo({339.873, 122.672}, {339.819, 122.804},
                         {339.75, 122.938})
           .CubicCurveTo({339.747, 122.944}, {339.743, 122.949},
                         {339.74, 122.955})
           .CubicCurveTo({339.674, 123.08}, {339.593, 123.205},
                         {339.501, 123.328})
           .CubicCurveTo({339.473, 123.366}, {339.441, 123.401},
                         {339.41, 123.438})
           .CubicCurveTo({339.332, 123.534}, {339.243, 123.625},
                         {339.145, 123.714})
           .CubicCurveTo({339.105, 123.75}, {339.068, 123.786},
                         {339.025, 123.821})
           .CubicCurveTo({338.881, 123.937}, {338.724, 124.048},
                         {338.539, 124.143})
           .CubicCurveTo({338.532, 123.959}, {338.554, 123.79},
                         {338.58, 123.626})
           .CubicCurveTo({338.58, 123.625}, {338.58, 123.625}, {338.58, 123.625})
           .CubicCurveTo({338.607, 123.455}, {338.65, 123.299},
                         {338.704, 123.151})
           .CubicCurveTo({338.708, 123.14}, {338.71, 123.127},
                         {338.714, 123.117})
           .CubicCurveTo({338.769, 122.971}, {338.833, 122.838},
                         {338.905, 122.712})
           .CubicCurveTo({338.911, 122.702}, {338.916, 122.69200000000001},
                         {338.922, 122.682})
           .CubicCurveTo({338.996, 122.557}, {339.072, 122.444},
                         {339.155, 122.34})
           .CubicCurveTo({339.161, 122.333}, {339.166, 122.326},
                         {339.172, 122.319})
           .CubicCurveTo({339.256, 122.215}, {339.339, 122.12},
                         {339.425, 122.037})
           .CubicCurveTo({339.428, 122.033}, {339.431, 122.03},
                         {339.435, 122.027})
           .CubicCurveTo({339.785, 121.687}, {340.106, 121.511},
                         {340.106, 121.511})
           .CubicCurveTo({340.106, 121.511}, {340.107, 121.645},
                         {340.082, 121.849})
           .Close()
           .MoveTo({340.678, 113.245})
           .CubicCurveTo({340.594, 113.488}, {340.356, 113.655},
                         {340.135, 113.775})
           .CubicCurveTo({339.817, 113.948}, {339.465, 114.059},
                         {339.115, 114.151})
           .CubicCurveTo({338.251, 114.379}, {337.34, 114.516},
                         {336.448, 114.516})
           .CubicCurveTo({335.761, 114.516}, {335.072, 114.527},
                         {334.384, 114.513})
           .CubicCurveTo({334.125, 114.508}, {333.862, 114.462},
                         {333.605, 114.424})
           .CubicCurveTo({332.865, 114.318}, {332.096, 114.184},
                         {331.41, 113.883})
           .CubicCurveTo({330.979, 113.695}, {330.442, 113.34},
                         {330.672, 112.813})
           .CubicCurveTo({331.135, 111.755}, {333.219, 112.946},
                         {334.526, 113.833})
           .CubicCurveTo({334.54, 113.816}, {334.554, 113.8}, {334.569, 113.784})
           .CubicCurveTo({333.38, 112.708}, {331.749, 110.985},
                         {332.76, 110.402})
           .CubicCurveTo({333.769, 109.82}, {334.713, 111.93},
                         {335.228, 113.395})
           .CubicCurveTo({334.915, 111.889}, {334.59, 109.636},
                         {335.661, 109.592})
           .CubicCurveTo({336.733, 109.636}, {336.408, 111.889},
                         {336.07, 113.389})
           .CubicCurveTo({336.609, 111.93}, {337.553, 109.82},
                         {338.563, 110.402})
           .CubicCurveTo({339.574, 110.984}, {337.942, 112.708},
                         {336.753, 113.784})
           .CubicCurveTo({336.768, 113.8}, {336.782, 113.816},
                         {336.796, 113.833})
           .CubicCurveTo({338.104, 112.946}, {340.187, 111.755},
                         {340.65, 112.813})
           .CubicCurveTo({340.71, 112.95}, {340.728, 113.102},
                         {340.678, 113.245})
           .Close()
           .MoveTo({346.357, 106.771})
           .CubicCurveTo({346.295, 104.987}, {347.924, 104.139},
                         {347.924, 104.139})
           .CubicCurveTo({347.924, 104.139}, {347.982, 105.931},
                         {346.357, 106.771})
           .Close()
           .MoveTo({347.56, 106.771})
           .CubicCurveTo({347.498, 104.987}, {349.127, 104.139},
                         {349.127, 104.139})
           .CubicCurveTo({349.127, 104.139}, {349.185, 105.931},
                         {347.56, 106.771})
           .Close()
           .TakePath();
   Entity entity;
   entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  
   std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
  
   auto contents = std::make_shared<SolidColorContents>();
   contents->SetColor(Color::Red());
   contents->SetGeometry(geom.get());
  
   entity.SetContents(contents);
   ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
 }

References impeller::Close(), impeller::LineTo(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [409/545]

impeller::testing::TEST_P	(	EntityTest	,
		CubicCurveTest
	)

Definition at line 370 of file entity_unittests.cc.

                                    {
   // Compare with https://fiddle.skia.org/c/b3625f26122c9de7afe7794fcf25ead3
   flutter::DlPath path =
       flutter::DlPathBuilder{}
           .MoveTo({237.164, 125.003})
           .CubicCurveTo({236.709, 125.184}, {236.262, 125.358},
                         {235.81, 125.538})
           .CubicCurveTo({235.413, 125.68}, {234.994, 125.832},
                         {234.592, 125.977})
           .CubicCurveTo({234.592, 125.977}, {234.591, 125.977},
                         {234.59, 125.977})
           .CubicCurveTo({222.206, 130.435}, {207.708, 135.753},
                         {192.381, 141.429})
           .CubicCurveTo({162.77, 151.336}, {122.17, 156.894}, {84.1123, 160})
           .Close()
           .TakePath();
   Entity entity;
   entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  
   std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
  
   auto contents = std::make_shared<SolidColorContents>();
   contents->SetColor(Color::Red());
   contents->SetGeometry(geom.get());
  
   entity.SetContents(contents);
   ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
 }

References impeller::Close(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [410/545]

impeller::testing::TEST_P	(	EntityTest	,
		DecalSpecializationAppliedToMorphologyFilter
	)

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

References impeller::kR8G8B8A8UNormInt.

◆ TEST_P() [411/545]

impeller::testing::TEST_P	(	EntityTest	,
		DrawRoundSuperEllipse
	)

Definition at line 2384 of file entity_unittests.cc.

                                           {
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     // UI state.
     static int style_index = 0;
     static float center[2] = {830, 830};
     static float size[2] = {600, 600};
     static bool horizontal_symmetry = true;
     static bool vertical_symmetry = true;
     static bool corner_symmetry = true;
  
     const char* style_options[] = {"Fill", "Stroke"};
  
     // Initially radius_tl[0] will be mirrored to all 8 values since all 3
     // symmetries are enabled.
     static std::array<float, 2> radius_tl = {200};
     static std::array<float, 2> radius_tr;
     static std::array<float, 2> radius_bl;
     static std::array<float, 2> radius_br;
  
     auto AddRadiusControl = [](std::array<float, 2>& radii, const char* tb_name,
                                const char* lr_name) {
       std::string name = "Radius";
       if (!horizontal_symmetry || !vertical_symmetry) {
         name += ":";
       }
       if (!vertical_symmetry) {
         name = name + " " + tb_name;
       }
       if (!horizontal_symmetry) {
         name = name + " " + lr_name;
       }
       if (corner_symmetry) {
         ImGui::SliderFloat(name.c_str(), radii.data(), 0, 1000);
       } else {
         ImGui::SliderFloat2(name.c_str(), radii.data(), 0, 1000);
       }
     };
  
     if (corner_symmetry) {
       radius_tl[1] = radius_tl[0];
       radius_tr[1] = radius_tr[0];
       radius_bl[1] = radius_bl[0];
       radius_br[1] = radius_br[0];
     }
  
     ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
     {
       ImGui::Combo("Style", &style_index, style_options,
                    sizeof(style_options) / sizeof(char*));
       ImGui::SliderFloat2("Center", center, 0, 1000);
       ImGui::SliderFloat2("Size", size, 0, 1000);
       ImGui::Checkbox("Symmetry: Horizontal", &horizontal_symmetry);
       ImGui::Checkbox("Symmetry: Vertical", &vertical_symmetry);
       ImGui::Checkbox("Symmetry: Corners", &corner_symmetry);
       AddRadiusControl(radius_tl, "Top", "Left");
       if (!horizontal_symmetry) {
         AddRadiusControl(radius_tr, "Top", "Right");
       } else {
         radius_tr = radius_tl;
       }
       if (!vertical_symmetry) {
         AddRadiusControl(radius_bl, "Bottom", "Left");
       } else {
         radius_bl = radius_tl;
       }
       if (!horizontal_symmetry && !vertical_symmetry) {
         AddRadiusControl(radius_br, "Bottom", "Right");
       } else {
         if (horizontal_symmetry) {
           radius_br = radius_bl;
         } else {
           radius_br = radius_tr;
         }
       }
     }
  
     ImGui::End();
  
     RoundingRadii radii{
         .top_left = {radius_tl[0], radius_tl[1]},
         .top_right = {radius_tr[0], radius_tr[1]},
         .bottom_left = {radius_bl[0], radius_bl[1]},
         .bottom_right = {radius_br[0], radius_br[1]},
     };
  
     auto rse = RoundSuperellipse::MakeRectRadii(
         RectMakeCenterSize({center[0], center[1]}, {size[0], size[1]}), radii);
  
     flutter::DlPath path;
     std::unique_ptr<Geometry> geom;
     if (style_index == 0) {
       geom = std::make_unique<RoundSuperellipseGeometry>(
           RectMakeCenterSize({center[0], center[1]}, {size[0], size[1]}),
           radii);
     } else {
       path = flutter::DlPath::MakeRoundSuperellipse(rse);
       geom = Geometry::MakeStrokePath(path, {.width = 2.0f});
     }
  
     auto contents = std::make_shared<SolidColorContents>();
     contents->SetColor(Color::Red());
     contents->SetGeometry(geom.get());
  
     Entity entity;
     entity.SetContents(contents);
  
     return entity.Render(context, pass);
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::RoundSuperellipse::MakeRectRadii(), impeller::Geometry::MakeStrokePath(), RectMakeCenterSize(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::RoundingRadii::top_left.

◆ TEST_P() [412/545]

impeller::testing::TEST_P	(	EntityTest	,
		DrawSuperEllipse
	)

Definition at line 2351 of file entity_unittests.cc.

                                      {
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     // UI state.
     static float alpha = 10;
     static float beta = 10;
     static float radius = 40;
     static int degree = 4;
     static Color color = Color::Red();
  
     ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
     ImGui::SliderFloat("Alpha", &alpha, 0, 100);
     ImGui::SliderFloat("Beta", &beta, 0, 100);
     ImGui::SliderInt("Degreee", &degree, 1, 20);
     ImGui::SliderFloat("Radius", &radius, 0, 400);
     ImGui::ColorEdit4("Color", reinterpret_cast<float*>(&color));
     ImGui::End();
  
     auto contents = std::make_shared<SolidColorContents>();
     std::unique_ptr<SuperellipseGeometry> geom =
         std::make_unique<SuperellipseGeometry>(Point{400, 400}, radius, degree,
                                                alpha, beta);
     contents->SetColor(color);
     contents->SetGeometry(geom.get());
  
     Entity entity;
     entity.SetContents(contents);
  
     return entity.Render(context, pass);
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::Red(), impeller::Entity::Render(), and impeller::Entity::SetContents().

◆ TEST_P() [413/545]

impeller::testing::TEST_P	(	EntityTest	,
		FailOnValidationError
	)

Definition at line 2300 of file entity_unittests.cc.

                                           {
   if (GetParam() != PlaygroundBackend::kVulkan) {
     GTEST_SKIP() << "Validation is only fatal on Vulkan backend.";
   }
   EXPECT_DEATH(
       // The easiest way to trigger a validation error is to try to compile
       // a shader with an unsupported pixel format.
       GetContentContext()->GetBlendColorBurnPipeline({
           .color_attachment_pixel_format = PixelFormat::kUnknown,
           .has_depth_stencil_attachments = false,
       }),
       "");
 }

References impeller::kUnknown, and impeller::kVulkan.

◆ TEST_P() [414/545]

impeller::testing::TEST_P	(	EntityTest	,
		FillPathGeometryGetPositionBufferReturnsExpectedMode
	)

Definition at line 2269 of file entity_unittests.cc.

                                                                          {
   RenderTarget target;
   testing::MockRenderPass mock_pass(GetContext(), target);
  
   auto get_result = [this, &mock_pass](const flutter::DlPath& path) {
     auto geometry = Geometry::MakeFillPath(
         path, /* inner rect */ Rect::MakeLTRB(0, 0, 100, 100));
     return geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
   };
  
   // Convex path
   {
     GeometryResult result =
         get_result(flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 100, 100)));
     EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal);
   }
  
   // Concave path
   {
     flutter::DlPath path = flutter::DlPathBuilder{}
                                .MoveTo({0, 0})
                                .LineTo({100, 0})
                                .LineTo({100, 100})
                                .LineTo({51, 50})
                                .Close()
                                .TakePath();
     GeometryResult result = get_result(path);
     EXPECT_EQ(result.mode, GeometryResult::Mode::kNonZero);
   }
 }

References impeller::Close(), impeller::GeometryResult::kNonZero, impeller::GeometryResult::kNormal, impeller::LineTo(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::GeometryResult::mode.

◆ TEST_P() [415/545]

impeller::testing::TEST_P	(	EntityTest	,
		FilterCoverageRespectsCropRect
	)

Definition at line 77 of file entity_unittests.cc.

                                                    {
   auto image = CreateTextureForFixture("boston.jpg");
   auto filter = ColorFilterContents::MakeBlend(BlendMode::kSoftLight,
                                                FilterInput::Make({image}));
  
   // Without the crop rect (default behavior).
   {
     auto actual = filter->GetCoverage({});
     auto expected = Rect::MakeSize(image->GetSize());
  
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
  
   // With the crop rect.
   {
     auto expected = Rect::MakeLTRB(50, 50, 100, 100);
     filter->SetCoverageHint(expected);
     auto actual = filter->GetCoverage({});
  
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
 }

References ASSERT_RECT_NEAR, impeller::kSoftLight, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::MakeSize().

◆ TEST_P() [416/545]

impeller::testing::TEST_P	(	EntityTest	,
		Filters
	)

Definition at line 919 of file entity_unittests.cc.

                             {
   auto bridge = CreateTextureForFixture("bay_bridge.jpg");
   auto boston = CreateTextureForFixture("boston.jpg");
   auto kalimba = CreateTextureForFixture("kalimba.jpg");
   ASSERT_TRUE(bridge && boston && kalimba);
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     auto fi_bridge = FilterInput::Make(bridge);
     auto fi_boston = FilterInput::Make(boston);
     auto fi_kalimba = FilterInput::Make(kalimba);
  
     std::shared_ptr<FilterContents> blend0 = ColorFilterContents::MakeBlend(
         BlendMode::kModulate, {fi_kalimba, fi_boston});
  
     auto blend1 = ColorFilterContents::MakeBlend(
         BlendMode::kScreen,
         {FilterInput::Make(blend0), fi_bridge, fi_bridge, fi_bridge});
  
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                         Matrix::MakeTranslation({500, 300}) *
                         Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity.SetContents(blend1);
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::kModulate, impeller::kScreen, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::Entity::SetTransform().

◆ TEST_P() [417/545]

impeller::testing::TEST_P	(	EntityTest	,
		GaussianBlurFilter
	)

Definition at line 947 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]);
  
     std::unique_ptr<Geometry> solid_color_input;
     if (selected_input_type == 0) {
       auto texture = std::make_shared<TextureContents>();
       texture->SetSourceRect(Rect::MakeSize(boston->GetSize()));
       texture->SetDestinationRect(input_rect);
       texture->SetTexture(boston);
       texture->SetOpacity(input_color.alpha);
  
       input = texture;
       input_size = input_rect.GetSize();
     } else {
       auto fill = std::make_shared<SolidColorContents>();
       fill->SetColor(input_color);
       solid_color_input =
           Geometry::MakeFillPath(flutter::DlPath::MakeRect(input_rect));
  
       fill->SetGeometry(solid_color_input.get());
  
       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;
     std::unique_ptr<Geometry> geom =
         Geometry::MakeFillPath(flutter::DlPath::MakeRect(input_rect));
     auto contents = std::make_shared<SolidColorContents>();
     contents->SetColor(cover_color);
     contents->SetGeometry(geom.get());
     cover_entity.SetContents(std::move(contents));
     cover_entity.SetTransform(ctm);
     cover_entity.Render(context, pass);
  
     // Renders a green bounding rect of the target filter.
     Entity bounds_entity;
     std::optional<Rect> target_contents_coverage =
         target_contents->GetCoverage(entity);
     if (target_contents_coverage.has_value()) {
       std::unique_ptr<Geometry> geom =
           Geometry::MakeFillPath(flutter::DlPath::MakeRect(
               target_contents->GetCoverage(entity).value()));
       auto contents = std::make_shared<SolidColorContents>();
       contents->SetColor(bounds_color);
       contents->SetGeometry(geom.get());
  
       bounds_entity.SetContents(contents);
       bounds_entity.SetTransform(Matrix());
       bounds_entity.Render(context, pass);
     }
  
     return true;
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::alpha, impeller::Color::Black(), impeller::Entity::GetCoverage(), impeller::Entity::kClamp, impeller::Entity::kDecal, impeller::FilterContents::kInner, impeller::Entity::kMirror, impeller::FilterContents::kNormal, impeller::FilterContents::kOuter, impeller::kPi, impeller::Entity::kRepeat, impeller::FilterContents::kSolid, impeller::FilterInput::Make(), impeller::FilterContents::MakeBorderMaskBlur(), impeller::Geometry::MakeFillPath(), impeller::FilterContents::MakeGaussianBlur(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeSkew(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [418/545]

impeller::testing::TEST_P	(	EntityTest	,
		GeometryBoundsAreTransformed
	)

Definition at line 102 of file entity_unittests.cc.

                                                  {
   auto geometry = Geometry::MakeRect(Rect::MakeXYWH(100, 100, 100, 100));
   auto transform = Matrix::MakeScale({2.0, 2.0, 2.0});
  
   ASSERT_RECT_NEAR(geometry->GetCoverage(transform).value(),
                    Rect::MakeXYWH(200, 200, 200, 200));
 }

References ASSERT_RECT_NEAR, impeller::Geometry::MakeRect(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST_P() [419/545]

impeller::testing::TEST_P	(	EntityTest	,
		GiantStrokePathAllocation
	)

Definition at line 2526 of file entity_unittests.cc.

                                               {
   flutter::DlPathBuilder builder;
   for (int i = 0; i < 10000; i++) {
     builder.LineTo(Point(i, i));
   }
   flutter::DlPath path = builder.TakePath();
   auto geom = Geometry::MakeStrokePath(path, {.width = 10.0f});
  
   ContentContext content_context(GetContext(), /*typographer_context=*/nullptr);
   Entity entity;
  
   auto cmd_buffer = content_context.GetContext()->CreateCommandBuffer();
  
   RenderTargetAllocator allocator(
       content_context.GetContext()->GetResourceAllocator());
  
   auto render_target = allocator.CreateOffscreen(
       *content_context.GetContext(), /*size=*/{10, 10}, /*mip_count=*/1);
   auto pass = cmd_buffer->CreateRenderPass(render_target);
  
   GeometryResult result =
       geom->GetPositionBuffer(content_context, entity, *pass);
  
   // Validate the buffer data overflowed the small buffer
   EXPECT_GT(result.vertex_buffer.vertex_count, kPointArenaSize);
  
   // Validate that there are no uninitialized points near the gap.
   Point* written_data = reinterpret_cast<Point*>(
       (result.vertex_buffer.vertex_buffer.GetBuffer()->OnGetContents() +
        result.vertex_buffer.vertex_buffer.GetRange().offset));
  
   std::vector<Point> expected = {
       Point(2043.46, 2050.54),  //
       Point(2050.54, 2043.46),  //
       Point(2044.46, 2051.54),  //
       Point(2051.54, 2044.46),  //
       Point(2045.46, 2052.54)   //
   };
  
   Point point = written_data[kPointArenaSize - 2];
   EXPECT_NEAR(point.x, expected[0].x, 0.1);
   EXPECT_NEAR(point.y, expected[0].y, 0.1);
  
   point = written_data[kPointArenaSize - 1];
   EXPECT_NEAR(point.x, expected[1].x, 0.1);
   EXPECT_NEAR(point.y, expected[1].y, 0.1);
  
   point = written_data[kPointArenaSize];
   EXPECT_NEAR(point.x, expected[2].x, 0.1);
   EXPECT_NEAR(point.y, expected[2].y, 0.1);
  
   point = written_data[kPointArenaSize + 1];
   EXPECT_NEAR(point.x, expected[3].x, 0.1);
   EXPECT_NEAR(point.y, expected[3].y, 0.1);
  
   point = written_data[kPointArenaSize + 2];
   EXPECT_NEAR(point.x, expected[4].x, 0.1);
   EXPECT_NEAR(point.y, expected[4].y, 0.1);
 }

References impeller::RenderTargetAllocator::CreateOffscreen(), impeller::BufferView::GetBuffer(), impeller::BufferView::GetRange(), impeller::kPointArenaSize, impeller::Geometry::MakeStrokePath(), impeller::Range::offset, impeller::DeviceBuffer::OnGetContents(), impeller::VertexBuffer::vertex_buffer, impeller::GeometryResult::vertex_buffer, impeller::VertexBuffer::vertex_count, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [420/545]

impeller::testing::TEST_P	(	EntityTest	,
		LinearGradientContentsIsOpaque
	)

Definition at line 2067 of file entity_unittests.cc.

                                                    {
   Matrix matrix;
   LinearGradientContents contents;
   auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
   contents.SetGeometry(geom.get());
  
   contents.SetColors({Color::CornflowerBlue()});
   EXPECT_TRUE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
   EXPECT_FALSE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue()});
   contents.SetTileMode(Entity::TileMode::kDecal);
   EXPECT_FALSE(contents.IsOpaque(matrix));
  
   // Create stroked path that required alpha coverage.
   geom = Geometry::MakeStrokePath(
       flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
       {.width = 0.05f});
   contents.SetGeometry(geom.get());
   contents.SetColors({Color::CornflowerBlue()});
  
   EXPECT_FALSE(contents.IsOpaque(matrix));
 }

References impeller::Color::CornflowerBlue(), impeller::LinearGradientContents::IsOpaque(), impeller::Entity::kDecal, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), impeller::LinearGradientContents::SetColors(), impeller::ColorSourceContents::SetGeometry(), impeller::LinearGradientContents::SetTileMode(), and impeller::Color::WithAlpha().

◆ TEST_P() [421/545]

impeller::testing::TEST_P	(	EntityTest	,
		LinearToSrgbFilter
	)

Definition at line 1556 of file entity_unittests.cc.

                                        {
   auto image = CreateTextureForFixture("kalimba.jpg");
   ASSERT_TRUE(image);
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     auto filtered =
         ColorFilterContents::MakeLinearToSrgbFilter(FilterInput::Make(image));
  
     // Define the entity that will serve as the control image as a Gaussian blur
     // filter with no filter at all.
     Entity entity_left;
     entity_left.SetTransform(Matrix::MakeScale(GetContentScale()) *
                              Matrix::MakeTranslation({100, 300}) *
                              Matrix::MakeScale(Vector2{0.5, 0.5}));
     auto unfiltered = FilterContents::MakeGaussianBlur(FilterInput::Make(image),
                                                        Sigma{0}, Sigma{0});
     entity_left.SetContents(unfiltered);
  
     // Define the entity that will be filtered from linear to sRGB.
     Entity entity_right;
     entity_right.SetTransform(Matrix::MakeScale(GetContentScale()) *
                               Matrix::MakeTranslation({500, 300}) *
                               Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity_right.SetContents(filtered);
     return entity_left.Render(context, pass) &&
            entity_right.Render(context, pass);
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::FilterInput::Make(), impeller::FilterContents::MakeGaussianBlur(), impeller::ColorFilterContents::MakeLinearToSrgbFilter(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [422/545]

impeller::testing::TEST_P	(	EntityTest	,
		LinearToSrgbFilterCoverageIsCorrect
	)

Definition at line 1534 of file entity_unittests.cc.

                                                         {
   // Set up a simple color background.
   auto geom = Geometry::MakeFillPath(
       flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
   auto fill = std::make_shared<SolidColorContents>();
   fill->SetGeometry(geom.get());
   fill->SetColor(Color::MintCream());
  
   auto filter =
       ColorFilterContents::MakeLinearToSrgbFilter(FilterInput::Make(fill));
  
   Entity e;
   e.SetTransform(Matrix());
  
   // Confirm that the actual filter coverage matches the expected coverage.
   auto actual = filter->GetCoverage(e);
   auto expected = Rect::MakeXYWH(0, 0, 300, 400);
  
   ASSERT_TRUE(actual.has_value());
   ASSERT_RECT_NEAR(actual.value(), expected);
 }

References ASSERT_RECT_NEAR, impeller::FilterInput::Make(), impeller::Geometry::MakeFillPath(), impeller::ColorFilterContents::MakeLinearToSrgbFilter(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Color::MintCream(), and impeller::Entity::SetTransform().

◆ TEST_P() [423/545]

impeller::testing::TEST_P	(	EntityTest	,
		MorphologyFilter
	)

Definition at line 1129 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;
     std::unique_ptr<Geometry> geom =
         Geometry::MakeFillPath(flutter::DlPath::MakeRect(input_rect));
     auto cover_contents = std::make_shared<SolidColorContents>();
     cover_contents->SetColor(cover_color);
     cover_contents->SetGeometry(geom.get());
     cover_entity.SetContents(cover_contents);
     cover_entity.SetTransform(ctm);
     cover_entity.Render(context, pass);
  
     // Renders a green bounding rect of the target filter.
     Entity bounds_entity;
     std::unique_ptr<Geometry> bounds_geom = Geometry::MakeFillPath(
         flutter::DlPath::MakeRect(contents->GetCoverage(entity).value()));
     auto bounds_contents = std::make_shared<SolidColorContents>();
     bounds_contents->SetColor(bounds_color);
     bounds_contents->SetGeometry(bounds_geom.get());
     bounds_entity.SetContents(std::move(bounds_contents));
     bounds_entity.SetTransform(Matrix());
  
     bounds_entity.Render(context, pass);
  
     return true;
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::Color::alpha, impeller::Color::Black(), impeller::FilterContents::kDilate, impeller::FilterContents::kErode, impeller::kPi, impeller::FilterInput::Make(), impeller::Geometry::MakeFillPath(), impeller::FilterContents::MakeMorphology(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeSkew(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [424/545]

impeller::testing::TEST_P	(	EntityTest	,
		PointFieldGeometryCoverage
	)

Definition at line 2150 of file entity_unittests.cc.

                                                {
   std::vector<Point> points = {{10, 20}, {100, 200}};
   PointFieldGeometry geometry(points.data(), 2, 5.0, false);
   ASSERT_EQ(geometry.GetCoverage(Matrix()), Rect::MakeLTRB(5, 15, 105, 205));
   ASSERT_EQ(geometry.GetCoverage(Matrix::MakeTranslation({30, 0, 0})),
             Rect::MakeLTRB(35, 15, 135, 205));
 }

References impeller::PointFieldGeometry::GetCoverage(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), and points.

◆ TEST_P() [425/545]

impeller::testing::TEST_P	(	EntityTest	,
		RadialGradientContentsIsOpaque
	)

Definition at line 2091 of file entity_unittests.cc.

                                                    {
   Matrix matrix;
   RadialGradientContents contents;
   auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
   contents.SetGeometry(geom.get());
  
   contents.SetColors({Color::CornflowerBlue()});
   EXPECT_TRUE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
   EXPECT_FALSE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue()});
   contents.SetTileMode(Entity::TileMode::kDecal);
   EXPECT_FALSE(contents.IsOpaque(matrix));
  
   // Create stroked path that required alpha coverage.
   geom = Geometry::MakeStrokePath(
       flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
       {.width = 0.05});
   contents.SetGeometry(geom.get());
   contents.SetColors({Color::CornflowerBlue()});
  
   EXPECT_FALSE(contents.IsOpaque(matrix));
 }

References impeller::Color::CornflowerBlue(), impeller::RadialGradientContents::IsOpaque(), impeller::Entity::kDecal, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), impeller::RadialGradientContents::SetColors(), impeller::ColorSourceContents::SetGeometry(), impeller::RadialGradientContents::SetTileMode(), and impeller::Color::WithAlpha().

◆ TEST_P() [426/545]

impeller::testing::TEST_P	(	EntityTest	,
		RoundSuperellipseGetPositionBufferFlushes
	)

Definition at line 2644 of file entity_unittests.cc.

                                                               {
   RenderTarget target;
   testing::MockRenderPass mock_pass(GetContext(), target);
  
   auto content_context = std::make_shared<FlushTestContentContext>(
       GetContext(), GetTypographerContext(),
       std::make_shared<FlushTestAllocator>());
   auto geometry =
       Geometry::MakeRoundSuperellipse(Rect::MakeLTRB(0, 0, 100, 100), 5);
   auto result = geometry->GetPositionBuffer(*content_context, {}, mock_pass);
  
   auto device_buffer = reinterpret_cast<const FlushTestDeviceBuffer*>(
       result.vertex_buffer.vertex_buffer.GetBuffer());
   EXPECT_TRUE(device_buffer->flush_called());
 }

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

◆ TEST_P() [427/545]

impeller::testing::TEST_P	(	EntityTest	,
		RRectShadowTest
	)

Definition at line 1392 of file entity_unittests.cc.

                                     {
   auto callback = [&](ContentContext& context, RenderPass& pass) {
     static Color color = Color::Red();
     static float corner_radius = 100;
     static float blur_radius = 100;
     static bool show_coverage = false;
     static Color coverage_color = Color::Green().WithAlpha(0.2);
     static PlaygroundPoint top_left_point(Point(200, 200), 30, Color::White());
     static PlaygroundPoint bottom_right_point(Point(600, 400), 30,
                                               Color::White());
  
     ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
     ImGui::SliderFloat("Corner radius", &corner_radius, 0, 300);
     ImGui::SliderFloat("Blur radius", &blur_radius, 0, 300);
     ImGui::ColorEdit4("Color", reinterpret_cast<Scalar*>(&color));
     ImGui::Checkbox("Show coverage", &show_coverage);
     if (show_coverage) {
       ImGui::ColorEdit4("Coverage color",
                         reinterpret_cast<Scalar*>(&coverage_color));
     }
     ImGui::End();
  
     auto [top_left, bottom_right] =
         DrawPlaygroundLine(top_left_point, bottom_right_point);
     auto rect =
         Rect::MakeLTRB(top_left.x, top_left.y, bottom_right.x, bottom_right.y);
  
     auto contents = std::make_unique<SolidRRectBlurContents>();
     contents->SetShape(rect, corner_radius);
     contents->SetColor(color);
     contents->SetSigma(Radius(blur_radius));
  
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()));
     entity.SetContents(std::move(contents));
     entity.Render(context, pass);
  
     auto coverage = entity.GetCoverage();
     if (show_coverage && coverage.has_value()) {
       auto bounds_contents = std::make_unique<SolidColorContents>();
       auto geom = Geometry::MakeFillPath(
           flutter::DlPath::MakeRect(entity.GetCoverage().value()));
       bounds_contents->SetGeometry(geom.get());
       bounds_contents->SetColor(coverage_color.Premultiply());
       Entity bounds_entity;
       bounds_entity.SetContents(std::move(bounds_contents));
       bounds_entity.Render(context, pass);
     }
  
     return true;
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References blur_radius, impeller::DrawPlaygroundLine(), impeller::Entity::GetCoverage(), impeller::Color::Green(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Color::Premultiply(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Color::White(), and impeller::Color::WithAlpha().

◆ TEST_P() [428/545]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffect
	)

Definition at line 1752 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;
  
   PipelineRef first_pipeline;
   std::unique_ptr<Geometry> geom = Geometry::MakeCover();
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     EXPECT_EQ(runtime_stage->IsDirty(), expect_dirty);
  
     auto contents = std::make_shared<RuntimeEffectContents>();
     contents->SetGeometry(geom.get());
     contents->SetRuntimeStage(runtime_stage);
  
     struct FragUniforms {
       Vector2 iResolution;
       Scalar iTime;
     } frag_uniforms = {
         .iResolution = Vector2(GetWindowSize().width, GetWindowSize().height),
         .iTime = static_cast<Scalar>(GetSecondsElapsed()),
     };
     auto uniform_data = std::make_shared<std::vector<uint8_t>>();
     uniform_data->resize(sizeof(FragUniforms));
     memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
     contents->SetUniformData(uniform_data);
  
     Entity entity;
     entity.SetContents(contents);
     bool result = contents->Render(context, entity, pass);
  
     if (expect_dirty) {
       first_pipeline = pass.GetCommands().back().pipeline;
     } else {
       EXPECT_EQ(pass.GetCommands().back().pipeline, first_pipeline);
     }
     expect_dirty = false;
     return result;
   };
  
   // Simulate some renders and hot reloading of the shader.
   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);
   }
 }

References impeller::Geometry::MakeCover(), impeller::PlaygroundBackendToRuntimeStageBackend(), and impeller::Entity::SetContents().

◆ TEST_P() [429/545]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectCanPrecache
	)

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

References impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [430/545]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectCanSuccessfullyRender
	)

Definition at line 1820 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>();
   auto geom = Geometry::MakeCover();
   contents->SetGeometry(geom.get());
   contents->SetRuntimeStage(runtime_stage);
  
   struct FragUniforms {
     Vector2 iResolution;
     Scalar iTime;
   } frag_uniforms = {
       .iResolution = Vector2(GetWindowSize().width, GetWindowSize().height),
       .iTime = static_cast<Scalar>(GetSecondsElapsed()),
   };
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(FragUniforms));
   memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
   contents->SetUniformData(uniform_data);
  
   Entity entity;
   entity.SetContents(contents);
  
   // Create a render target with a depth-stencil, similar to how EntityPass
   // does.
   RenderTarget target =
       GetContentContext()->GetRenderTargetCache()->CreateOffscreenMSAA(
           *GetContext(), {GetWindowSize().width, GetWindowSize().height}, 1,
           "RuntimeEffect Texture");
   testing::MockRenderPass pass(GetContext(), target);
  
   ASSERT_TRUE(contents->Render(*GetContentContext(), entity, pass));
   ASSERT_EQ(pass.GetCommands().size(), 1u);
   const auto& command = pass.GetCommands()[0];
   ASSERT_TRUE(command.pipeline->GetDescriptor()
                   .GetDepthStencilAttachmentDescriptor()
                   .has_value());
   ASSERT_TRUE(command.pipeline->GetDescriptor()
                   .GetFrontStencilAttachmentDescriptor()
                   .has_value());
 }

References impeller::Geometry::MakeCover(), impeller::PlaygroundBackendToRuntimeStageBackend(), and impeller::Entity::SetContents().

◆ TEST_P() [431/545]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectSetsRightSizeWhenUniformIsStruct
	)

Definition at line 1881 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>();
   auto geom = Geometry::MakeCover();
   contents->SetGeometry(geom.get());
   contents->SetRuntimeStage(runtime_stage);
  
   struct FragUniforms {
     Vector2 iResolution;
     Scalar iTime;
   } frag_uniforms = {
       .iResolution = Vector2(GetWindowSize().width, GetWindowSize().height),
       .iTime = static_cast<Scalar>(GetSecondsElapsed()),
   };
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(FragUniforms));
   memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
  
   auto buffer_view = RuntimeEffectContents::EmplaceVulkanUniform(
       uniform_data, GetContentContext()->GetTransientsBuffer(),
       runtime_stage->GetUniforms()[0],
       GetContentContext()->GetTransientsBuffer().GetMinimumUniformAlignment());
  
   // 16 bytes:
   //   8 bytes for iResolution
   //   4 bytes for iTime
   //   4 bytes padding
   EXPECT_EQ(buffer_view.GetRange().length, 16u);
 }

References buffer_view, impeller::RuntimeEffectContents::EmplaceVulkanUniform(), impeller::kVulkan, impeller::Geometry::MakeCover(), and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [432/545]

impeller::testing::TEST_P	(	EntityTest	,
		SetBlendMode
	)

Definition at line 1235 of file entity_unittests.cc.

                                  {
   Entity entity;
   ASSERT_EQ(entity.GetBlendMode(), BlendMode::kSrcOver);
   entity.SetBlendMode(BlendMode::kClear);
   ASSERT_EQ(entity.GetBlendMode(), BlendMode::kClear);
 }

References impeller::Entity::GetBlendMode(), impeller::kClear, impeller::kSrcOver, and impeller::Entity::SetBlendMode().

◆ TEST_P() [433/545]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorApplyColorFilter
	)

Definition at line 2496 of file entity_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));
 }

References ASSERT_COLOR_NEAR, impeller::Color::Blend(), impeller::Color::CornflowerBlue(), impeller::kScreen, and impeller::Color::LimeGreen().

◆ TEST_P() [434/545]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsIsOpaque
	)

Definition at line 2026 of file entity_unittests.cc.

                                                {
   Matrix matrix;
   SolidColorContents contents;
   auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
   contents.SetGeometry(geom.get());
  
   contents.SetColor(Color::CornflowerBlue());
   EXPECT_TRUE(contents.IsOpaque(matrix));
   contents.SetColor(Color::CornflowerBlue().WithAlpha(0.5));
   EXPECT_FALSE(contents.IsOpaque(matrix));
  
   // Create stroked path that required alpha coverage.
   geom = Geometry::MakeStrokePath(flutter::DlPath::MakeLine({0, 0}, {100, 100}),
                                   {.width = 0.05});
   contents.SetGeometry(geom.get());
   contents.SetColor(Color::CornflowerBlue());
  
   EXPECT_FALSE(contents.IsOpaque(matrix));
 }

References impeller::Color::CornflowerBlue(), impeller::SolidColorContents::IsOpaque(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), impeller::SolidColorContents::SetColor(), and impeller::ColorSourceContents::SetGeometry().

◆ TEST_P() [435/545]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsStrokeSetMiterLimit
	)

Definition at line 719 of file entity_unittests.cc.

                                                           {
   {
     auto geometry = Geometry::MakeStrokePath(flutter::DlPath{});
     auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
     ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
   }
  
   {
     auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                              {
                                                  .width = 1.0f,
                                                  .miter_limit = 8.0f,
                                              });
     auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
     ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 8);
   }
  
   {
     auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                              {
                                                  .width = 1.0f,
                                                  .miter_limit = -1.0f,
                                              });
     auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
     ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
   }
 }

References impeller::Geometry::MakeStrokePath().

◆ TEST_P() [436/545]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsStrokeSetStrokeCapsAndJoins
	)

Definition at line 687 of file entity_unittests.cc.

                                                                   {
   {
     auto geometry = Geometry::MakeStrokePath(flutter::DlPath{});
     auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
     // Defaults.
     ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kButt);
     ASSERT_EQ(path_geometry->GetStrokeJoin(), Join::kMiter);
   }
  
   {
     auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                              {
                                                  .width = 1.0f,
                                                  .cap = Cap::kSquare,
                                                  .miter_limit = 4.0f,
                                              });
     auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
     ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kSquare);
   }
  
   {
     auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                              {
                                                  .width = 1.0f,
                                                  .cap = Cap::kRound,
                                                  .miter_limit = 4.0f,
                                              });
     auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
     ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kRound);
   }
 }

References impeller::kButt, impeller::kMiter, impeller::kRound, impeller::kSquare, and impeller::Geometry::MakeStrokePath().

◆ TEST_P() [437/545]

impeller::testing::TEST_P	(	EntityTest	,
		SolidFillCoverageIsCorrect
	)

Definition at line 1347 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);
     auto geom = Geometry::MakeFillPath(flutter::DlPath::MakeRect(expected));
     fill->SetGeometry(geom.get());
  
     auto coverage = fill->GetCoverage({});
     ASSERT_TRUE(coverage.has_value());
     ASSERT_RECT_NEAR(coverage.value(), expected);
   }
  
   // Entity transform
   {
     auto fill = std::make_shared<SolidColorContents>();
     auto geom = Geometry::MakeFillPath(
         flutter::DlPath::MakeRect(Rect::MakeLTRB(100, 110, 200, 220)));
     fill->SetColor(Color::CornflowerBlue());
     fill->SetGeometry(geom.get());
  
     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>();
     auto geom = Geometry::MakeFillPath(
         flutter::DlPath::MakeRect(Rect::MakeLTRB(100, 110, 200, 220)));
     fill->SetColor(Color::WhiteTransparent());
     fill->SetGeometry(geom.get());
  
     auto coverage = fill->GetCoverage({});
     ASSERT_FALSE(coverage.has_value());
   }
 }

References ASSERT_RECT_NEAR, impeller::Color::CornflowerBlue(), impeller::Entity::GetCoverage(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Color::WhiteTransparent().

◆ TEST_P() [438/545]

impeller::testing::TEST_P	(	EntityTest	,
		SolidStrokeCoverageIsCorrect
	)

Definition at line 1248 of file entity_unittests.cc.

                                                  {
   {
     auto geometry = Geometry::MakeStrokePath(
         flutter::DlPath::MakeLine({0, 0}, {10, 10}),  //
         {
             .width = 4.0f,
             .cap = Cap::kButt,
             .join = Join::kBevel,
             .miter_limit = 4.0f,
         });
  
     Entity entity;
     auto contents = std::make_unique<SolidColorContents>();
     contents->SetGeometry(geometry.get());
     contents->SetColor(Color::Black());
     entity.SetContents(std::move(contents));
     auto actual = entity.GetCoverage();
     auto expected = Rect::MakeLTRB(-2, -2, 12, 12);
  
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
  
   // Cover the Cap::kSquare case.
   {
     auto geometry = Geometry::MakeStrokePath(
         flutter::DlPath::MakeLine({0, 0}, {10, 10}),  //
         {
             .width = 4.0,
             .cap = Cap::kSquare,
             .join = Join::kBevel,
             .miter_limit = 4.0,
         });
  
     Entity entity;
     auto contents = std::make_unique<SolidColorContents>();
     contents->SetGeometry(geometry.get());
     contents->SetColor(Color::Black());
     entity.SetContents(std::move(contents));
     auto actual = entity.GetCoverage();
     auto expected =
         Rect::MakeLTRB(-sqrt(8), -sqrt(8), 10 + sqrt(8), 10 + sqrt(8));
  
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
  
   // Cover the Join::kMiter case.
   {
     auto geometry = Geometry::MakeStrokePath(
         flutter::DlPath::MakeLine({0, 0}, {10, 10}),  //
         {
             .width = 4.0f,
             .cap = Cap::kSquare,
             .join = Join::kMiter,
             .miter_limit = 2.0f,
         });
  
     Entity entity;
     auto contents = std::make_unique<SolidColorContents>();
     contents->SetGeometry(geometry.get());
     contents->SetColor(Color::Black());
     entity.SetContents(std::move(contents));
     auto actual = entity.GetCoverage();
     auto expected = Rect::MakeLTRB(-4, -4, 14, 14);
  
     ASSERT_TRUE(actual.has_value());
     ASSERT_RECT_NEAR(actual.value(), expected);
   }
 }

References ASSERT_RECT_NEAR, impeller::Color::Black(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kSquare, impeller::TRect< Scalar >::MakeLTRB(), and impeller::Geometry::MakeStrokePath().

◆ TEST_P() [439/545]

impeller::testing::TEST_P	(	EntityTest	,
		SpecializationConstantsAreAppliedToVariants
	)

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

References impeller::kA8UNormInt, and impeller::kR8G8B8A8UNormInt.

◆ TEST_P() [440/545]

impeller::testing::TEST_P	(	EntityTest	,
		SrgbToLinearFilter
	)

Definition at line 1609 of file entity_unittests.cc.

                                        {
   auto image = CreateTextureForFixture("embarcadero.jpg");
   ASSERT_TRUE(image);
  
   auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
     auto filtered =
         ColorFilterContents::MakeSrgbToLinearFilter(FilterInput::Make(image));
  
     // Define the entity that will serve as the control image as a Gaussian blur
     // filter with no filter at all.
     Entity entity_left;
     entity_left.SetTransform(Matrix::MakeScale(GetContentScale()) *
                              Matrix::MakeTranslation({100, 300}) *
                              Matrix::MakeScale(Vector2{0.5, 0.5}));
     auto unfiltered = FilterContents::MakeGaussianBlur(FilterInput::Make(image),
                                                        Sigma{0}, Sigma{0});
     entity_left.SetContents(unfiltered);
  
     // Define the entity that will be filtered from sRGB to linear.
     Entity entity_right;
     entity_right.SetTransform(Matrix::MakeScale(GetContentScale()) *
                               Matrix::MakeTranslation({500, 300}) *
                               Matrix::MakeScale(Vector2{0.5, 0.5}));
     entity_right.SetContents(filtered);
     return entity_left.Render(context, pass) &&
            entity_right.Render(context, pass);
   };
  
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::FilterInput::Make(), impeller::FilterContents::MakeGaussianBlur(), impeller::Matrix::MakeScale(), impeller::ColorFilterContents::MakeSrgbToLinearFilter(), impeller::Matrix::MakeTranslation(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [441/545]

impeller::testing::TEST_P	(	EntityTest	,
		SrgbToLinearFilterCoverageIsCorrect
	)

Definition at line 1587 of file entity_unittests.cc.

                                                         {
   // Set up a simple color background.
   auto fill = std::make_shared<SolidColorContents>();
   auto geom = Geometry::MakeFillPath(
       flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
   fill->SetGeometry(geom.get());
   fill->SetColor(Color::DeepPink());
  
   auto filter =
       ColorFilterContents::MakeSrgbToLinearFilter(FilterInput::Make(fill));
  
   Entity e;
   e.SetTransform(Matrix());
  
   // Confirm that the actual filter coverage matches the expected coverage.
   auto actual = filter->GetCoverage(e);
   auto expected = Rect::MakeXYWH(0, 0, 300, 400);
  
   ASSERT_TRUE(actual.has_value());
   ASSERT_RECT_NEAR(actual.value(), expected);
 }

References ASSERT_RECT_NEAR, impeller::Color::DeepPink(), impeller::FilterInput::Make(), impeller::Geometry::MakeFillPath(), impeller::ColorFilterContents::MakeSrgbToLinearFilter(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Entity::SetTransform().

◆ TEST_P() [442/545]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeCapAndJoinTest
	)

Definition at line 200 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 flutter::DlPath& path, Cap cap, Join join) {
       auto contents = std::make_unique<SolidColorContents>();
       std::unique_ptr<Geometry> geom =
           Geometry::MakeStrokePath(path, {
                                              .width = width,
                                              .cap = cap,
                                              .join = join,
                                              .miter_limit = miter_limit,
                                          });
       contents->SetGeometry(geom.get());
       contents->SetColor(Color::Red());
  
       Entity entity;
       entity.SetTransform(world_matrix);
       entity.SetContents(std::move(contents));
  
       auto coverage = entity.GetCoverage();
       if (coverage.has_value()) {
         auto bounds_contents = std::make_unique<SolidColorContents>();
  
         std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(
             flutter::DlPath::MakeRect(entity.GetCoverage().value()));
  
         bounds_contents->SetGeometry(geom.get());
         bounds_contents->SetColor(Color::Green().WithAlpha(0.5));
         Entity bounds_entity;
         bounds_entity.SetContents(std::move(bounds_contents));
         bounds_entity.Render(context, pass);
       }
  
       entity.Render(context, pass);
     };
  
     const Point a_def(0, 0), b_def(0, 100), c_def(150, 0), d_def(150, -100),
         e_def(75, 75);
     const Scalar r = 30;
     // Cap::kButt demo.
     {
       Point off = Point(0, 0) * padding + margin;
       static PlaygroundPoint point_a(off + a_def, r, Color::Black());
       static PlaygroundPoint point_b(off + b_def, r, Color::White());
       auto [a, b] = DrawPlaygroundLine(point_a, point_b);
       static PlaygroundPoint point_c(off + c_def, r, Color::Black());
       static PlaygroundPoint point_d(off + d_def, r, Color::White());
       auto [c, d] = DrawPlaygroundLine(point_c, point_d);
       render_path(flutter::DlPathBuilder{}  //
                       .MoveTo(a)
                       .CubicCurveTo(b, d, c)
                       .TakePath(),
                   Cap::kButt, Join::kBevel);
     }
  
     // Cap::kSquare demo.
     {
       Point off = Point(1, 0) * padding + margin;
       static PlaygroundPoint point_a(off + a_def, r, Color::Black());
       static PlaygroundPoint point_b(off + b_def, r, Color::White());
       auto [a, b] = DrawPlaygroundLine(point_a, point_b);
       static PlaygroundPoint point_c(off + c_def, r, Color::Black());
       static PlaygroundPoint point_d(off + d_def, r, Color::White());
       auto [c, d] = DrawPlaygroundLine(point_c, point_d);
       render_path(flutter::DlPathBuilder{}  //
                       .MoveTo(a)
                       .CubicCurveTo(b, d, c)
                       .TakePath(),
                   Cap::kSquare, Join::kBevel);
     }
  
     // Cap::kRound demo.
     {
       Point off = Point(2, 0) * padding + margin;
       static PlaygroundPoint point_a(off + a_def, r, Color::Black());
       static PlaygroundPoint point_b(off + b_def, r, Color::White());
       auto [a, b] = DrawPlaygroundLine(point_a, point_b);
       static PlaygroundPoint point_c(off + c_def, r, Color::Black());
       static PlaygroundPoint point_d(off + d_def, r, Color::White());
       auto [c, d] = DrawPlaygroundLine(point_c, point_d);
       render_path(flutter::DlPathBuilder{}  //
                       .MoveTo(a)
                       .CubicCurveTo(b, d, c)
                       .TakePath(),
                   Cap::kRound, Join::kBevel);
     }
  
     // Join::kBevel demo.
     {
       Point off = Point(0, 1) * padding + margin;
       static PlaygroundPoint point_a =
           PlaygroundPoint(off + a_def, r, Color::White());
       static PlaygroundPoint point_b =
           PlaygroundPoint(off + e_def, r, Color::White());
       static PlaygroundPoint point_c =
           PlaygroundPoint(off + c_def, r, Color::White());
       Point a = DrawPlaygroundPoint(point_a);
       Point b = DrawPlaygroundPoint(point_b);
       Point c = DrawPlaygroundPoint(point_c);
       render_path(flutter::DlPathBuilder{}  //
                       .MoveTo(a)
                       .LineTo(b)
                       .LineTo(c)
                       .Close()
                       .TakePath(),
                   Cap::kButt, Join::kBevel);
     }
  
     // Join::kMiter demo.
     {
       Point off = Point(1, 1) * padding + margin;
       static PlaygroundPoint point_a(off + a_def, r, Color::White());
       static PlaygroundPoint point_b(off + e_def, r, Color::White());
       static PlaygroundPoint point_c(off + c_def, r, Color::White());
       Point a = DrawPlaygroundPoint(point_a);
       Point b = DrawPlaygroundPoint(point_b);
       Point c = DrawPlaygroundPoint(point_c);
       render_path(flutter::DlPathBuilder{}  //
                       .MoveTo(a)
                       .LineTo(b)
                       .LineTo(c)
                       .Close()
                       .TakePath(),
                   Cap::kButt, Join::kMiter);
     }
  
     // Join::kRound demo.
     {
       Point off = Point(2, 1) * padding + margin;
       static PlaygroundPoint point_a(off + a_def, r, Color::White());
       static PlaygroundPoint point_b(off + e_def, r, Color::White());
       static PlaygroundPoint point_c(off + c_def, r, Color::White());
       Point a = DrawPlaygroundPoint(point_a);
       Point b = DrawPlaygroundPoint(point_b);
       Point c = DrawPlaygroundPoint(point_c);
       render_path(flutter::DlPathBuilder{}  //
                       .MoveTo(a)
                       .LineTo(b)
                       .LineTo(c)
                       .Close()
                       .TakePath(),
                   Cap::kButt, Join::kRound);
     }
  
     return true;
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::saturated::b, impeller::Color::Black(), impeller::Close(), impeller::DrawPlaygroundLine(), impeller::DrawPlaygroundPoint(), impeller::Entity::GetCoverage(), impeller::Color::Green(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kRound, impeller::kSquare, impeller::LineTo(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), padding, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Color::White().

◆ TEST_P() [443/545]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeWithTextureContents
	)

Definition at line 132 of file entity_unittests.cc.

                                               {
   auto bridge = CreateTextureForFixture("bay_bridge.jpg");
   flutter::DlPath path = flutter::DlPathBuilder{}
                              .MoveTo({100, 100})
                              .LineTo({100, 200})
                              .MoveTo({100, 300})
                              .LineTo({100, 400})
                              .MoveTo({100, 500})
                              .LineTo({100, 600})
                              .TakePath();
  
   Entity entity;
   entity.SetTransform(Matrix::MakeScale(GetContentScale()));
   auto contents = std::make_unique<TiledTextureContents>();
   std::unique_ptr<Geometry> geom =
       Geometry::MakeStrokePath(path, {.width = 100.0f});
   contents->SetGeometry(geom.get());
   contents->SetTexture(bridge);
   contents->SetTileModes(Entity::TileMode::kClamp, Entity::TileMode::kClamp);
   entity.SetContents(std::move(contents));
   ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
 }

References impeller::Entity::kClamp, impeller::LineTo(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), impeller::MoveTo(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [444/545]

impeller::testing::TEST_P	(	EntityTest	,
		SweepGradientContentsIsOpaque
	)

Definition at line 2115 of file entity_unittests.cc.

                                                   {
   Matrix matrix;
   RadialGradientContents contents;
   auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
   contents.SetGeometry(geom.get());
  
   contents.SetColors({Color::CornflowerBlue()});
   EXPECT_TRUE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
   EXPECT_FALSE(contents.IsOpaque(matrix));
   contents.SetColors({Color::CornflowerBlue()});
   contents.SetTileMode(Entity::TileMode::kDecal);
   EXPECT_FALSE(contents.IsOpaque(matrix));
  
   // Create stroked path that required alpha coverage.
   geom = Geometry::MakeStrokePath(
       flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
       {.width = 0.05f});
   contents.SetGeometry(geom.get());
   contents.SetColors({Color::CornflowerBlue()});
  
   EXPECT_FALSE(contents.IsOpaque(matrix));
 }

References impeller::Color::CornflowerBlue(), impeller::RadialGradientContents::IsOpaque(), impeller::Entity::kDecal, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), impeller::RadialGradientContents::SetColors(), impeller::ColorSourceContents::SetGeometry(), impeller::RadialGradientContents::SetTileMode(), and impeller::Color::WithAlpha().

◆ TEST_P() [445/545]

impeller::testing::TEST_P	(	EntityTest	,
		TextContentsCeilsGlyphScaleToDecimal
	)

Definition at line 2178 of file entity_unittests.cc.

                                                          {
   ASSERT_EQ(TextFrame::RoundScaledFontSize(0.4321111f), Rational(43, 100));
   ASSERT_EQ(TextFrame::RoundScaledFontSize(0.5321111f), Rational(53, 100));
   ASSERT_EQ(TextFrame::RoundScaledFontSize(2.1f), Rational(21, 10));
   ASSERT_EQ(TextFrame::RoundScaledFontSize(0.0f), Rational(0, 1));
   ASSERT_EQ(TextFrame::RoundScaledFontSize(100000000.0f), Rational(48, 1));
 }

References impeller::TextFrame::RoundScaledFontSize().

◆ TEST_P() [446/545]

impeller::testing::TEST_P	(	EntityTest	,
		ThreeStrokesInOnePath
	)

Definition at line 110 of file entity_unittests.cc.

                                           {
   flutter::DlPath path = flutter::DlPathBuilder{}
                              .MoveTo({100, 100})
                              .LineTo({100, 200})
                              .MoveTo({100, 300})
                              .LineTo({100, 400})
                              .MoveTo({100, 500})
                              .LineTo({100, 600})
                              .TakePath();
  
   Entity entity;
   entity.SetTransform(Matrix::MakeScale(GetContentScale()));
   auto contents = std::make_unique<SolidColorContents>();
  
   std::unique_ptr<Geometry> geom =
       Geometry::MakeStrokePath(path, {.width = 5.0f});
   contents->SetGeometry(geom.get());
   contents->SetColor(Color::Red());
   entity.SetContents(std::move(contents));
   ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
 }

References impeller::LineTo(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), impeller::MoveTo(), impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [447/545]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsIsOpaque
	)

Definition at line 2139 of file entity_unittests.cc.

                                                  {
   Matrix matrix;
   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.
   EXPECT_FALSE(contents.IsOpaque(matrix));
 }

References impeller::TiledTextureContents::IsOpaque(), and impeller::TiledTextureContents::SetTexture().

◆ TEST_P() [448/545]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsRendersWithCorrectPipeline
	)

Definition at line 21 of file tiled_texture_contents_unittests.cc.

                                                                    {
   TextureDescriptor texture_desc;
   texture_desc.size = {100, 100};
   texture_desc.type = TextureType::kTexture2D;
   texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
   texture_desc.storage_mode = StorageMode::kDevicePrivate;
   auto texture =
       GetContext()->GetResourceAllocator()->CreateTexture(texture_desc);
  
   auto geom = Geometry::MakeCover();
   TiledTextureContents contents;
   contents.SetTexture(texture);
   contents.SetGeometry(geom.get());
  
   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);
 #ifdef IMPELLER_DEBUG
   EXPECT_TRUE(commands[0].pipeline->GetDescriptor().GetLabel().find(
                   "TextureFill Pipeline") != std::string::npos);
 #endif  // IMPELLER_DEBUG
   auto options = OptionsFromPassAndEntity(*recording_pass, {});
   options.primitive_type = PrimitiveType::kTriangleStrip;
   EXPECT_EQ(commands[0].pipeline,
             GetContentContext()->GetTiledTexturePipeline(options));
  
   if (GetParam() == PlaygroundBackend::kMetal) {
     recording_pass->EncodeCommands();
   }
 }

References impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kMetal, impeller::kR8G8B8A8UNormInt, impeller::kTexture2D, impeller::kTriangleStrip, impeller::Geometry::MakeCover(), impeller::OptionsFromPassAndEntity(), impeller::ContentContextOptions::primitive_type, impeller::TiledTextureContents::Render(), impeller::ColorSourceContents::SetGeometry(), impeller::TiledTextureContents::SetTexture(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and impeller::TextureDescriptor::type.

◆ TEST_P() [449/545]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsRendersWithCorrectPipelineExternalOES
	)

Definition at line 65 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);
   auto contents = TextureContents::MakeRect(Rect::MakeSize(texture->GetSize()));
   contents->SetTexture(texture);
   contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
   contents->SetStrictSourceRect(false);
  
   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);
  
   auto options = OptionsFromPassAndEntity(*render_pass, {});
   options.primitive_type = PrimitiveType::kTriangleStrip;
   EXPECT_EQ(commands[0].pipeline,
             GetContentContext()->GetTiledTextureExternalPipeline(options));
 }

References impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kOpenGLES, impeller::kR8G8B8A8UNormInt, impeller::kTextureExternalOES, impeller::kTriangleStrip, impeller::TextureContents::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::OptionsFromPassAndEntity(), impeller::ContentContextOptions::primitive_type, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and impeller::TextureDescriptor::type.

◆ TEST_P() [450/545]

impeller::testing::TEST_P	(	EntityTest	,
		TriangleInsideASquare
	)

Definition at line 155 of file entity_unittests.cc.

                                           {
   auto callback = [&](ContentContext& context, RenderPass& pass) {
     Point offset(100, 100);
  
     static PlaygroundPoint point_a(Point(10, 10) + offset, 20, Color::White());
     Point a = DrawPlaygroundPoint(point_a);
     static PlaygroundPoint point_b(Point(210, 10) + offset, 20, Color::White());
     Point b = DrawPlaygroundPoint(point_b);
     static PlaygroundPoint point_c(Point(210, 210) + offset, 20,
                                    Color::White());
     Point c = DrawPlaygroundPoint(point_c);
     static PlaygroundPoint point_d(Point(10, 210) + offset, 20, Color::White());
     Point d = DrawPlaygroundPoint(point_d);
     static PlaygroundPoint point_e(Point(50, 50) + offset, 20, Color::White());
     Point e = DrawPlaygroundPoint(point_e);
     static PlaygroundPoint point_f(Point(100, 50) + offset, 20, Color::White());
     Point f = DrawPlaygroundPoint(point_f);
     static PlaygroundPoint point_g(Point(50, 150) + offset, 20, Color::White());
     Point g = DrawPlaygroundPoint(point_g);
     flutter::DlPath path = flutter::DlPathBuilder{}
                                .MoveTo(a)
                                .LineTo(b)
                                .LineTo(c)
                                .LineTo(d)
                                .Close()
                                .MoveTo(e)
                                .LineTo(f)
                                .LineTo(g)
                                .Close()
                                .TakePath();
  
     Entity entity;
     entity.SetTransform(Matrix::MakeScale(GetContentScale()));
     auto contents = std::make_unique<SolidColorContents>();
     std::unique_ptr<Geometry> geom =
         Geometry::MakeStrokePath(path, {.width = 20.0});
     contents->SetGeometry(geom.get());
     contents->SetColor(Color::Red());
     entity.SetContents(std::move(contents));
  
     return entity.Render(context, pass);
   };
   ASSERT_TRUE(OpenPlaygroundHere(callback));
 }

References impeller::saturated::b, impeller::DrawPlaygroundPoint(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Color::White().

◆ TEST_P() [451/545]

impeller::testing::TEST_P	(	EntityTest	,
		YUVToRGBFilter
	)

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

References CreateTestYUVTextures(), impeller::kBT601FullRange, impeller::kBT601LimitedRange, impeller::kOpenGLES, impeller::TRect< Scalar >::MakeLTRB(), impeller::TextureContents::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeTranslation(), impeller::FilterContents::MakeYUVToRGBFilter(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [452/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CalculateUVsSimple
	)

Definition at line 334 of file gaussian_blur_filter_contents_unittests.cc.

                                                            {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   auto filter_input = FilterInput::Make(texture);
   Entity entity;
   Quad uvs = GaussianBlurFilterContents::CalculateUVs(
       filter_input, entity, Rect::MakeSize(ISize(100, 100)), ISize(100, 100));
   std::optional<Rect> uvs_bounds = Rect::MakePointBounds(uvs);
   EXPECT_TRUE(uvs_bounds.has_value());
   if (uvs_bounds.has_value()) {
     EXPECT_TRUE(RectNear(uvs_bounds.value(), Rect::MakeXYWH(0, 0, 1, 1)));
   }
 }

References impeller::GaussianBlurFilterContents::CalculateUVs(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakePointBounds(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), RectNear(), and uvs.

◆ TEST_P() [453/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CoverageWithEffectTransform
	)

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

References EXPECT_RECT_NEAR, impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::Entity::SetTransform().

◆ TEST_P() [454/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CoverageWithTexture
	)

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

References EXPECT_RECT_NEAR, impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), and impeller::Entity::SetTransform().

◆ TEST_P() [455/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverage
	)

Definition at line 238 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::kSrcOver);
     std::optional<Rect> result_coverage = result.value().GetCoverage();
     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
     EXPECT_TRUE(result_coverage.has_value());
     EXPECT_TRUE(contents_coverage.has_value());
     if (result_coverage.has_value() && contents_coverage.has_value()) {
       EXPECT_TRUE(RectNear(contents_coverage.value(),
                            Rect::MakeLTRB(-1, -1, 101, 101)));
       EXPECT_TRUE(
           RectNear(result_coverage.value(), Rect::MakeLTRB(-1, -1, 101, 101)));
     }
   }
 }

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), and RectNear().

◆ TEST_P() [456/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverageRotated
	)

Definition at line 301 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::kSrcOver);
     std::optional<Rect> result_coverage = result.value().GetCoverage();
     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
     EXPECT_TRUE(result_coverage.has_value());
     EXPECT_TRUE(contents_coverage.has_value());
     if (result_coverage.has_value() && contents_coverage.has_value()) {
       EXPECT_TRUE(RectNear(contents_coverage.value(),
                            Rect::MakeLTRB(99, 99, 401, 501)));
       EXPECT_TRUE(
           RectNear(result_coverage.value(), Rect::MakeLTRB(99, 99, 401, 501)));
     }
   }
 }

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), RectNear(), and impeller::Entity::SetTransform().

◆ TEST_P() [457/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverageTranslate
	)

Definition at line 268 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::kSrcOver);
     std::optional<Rect> result_coverage = result.value().GetCoverage();
     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
     EXPECT_TRUE(result_coverage.has_value());
     EXPECT_TRUE(contents_coverage.has_value());
     if (result_coverage.has_value() && contents_coverage.has_value()) {
       EXPECT_TRUE(RectNear(contents_coverage.value(),
                            Rect::MakeLTRB(99, 199, 201, 301)));
       EXPECT_TRUE(
           RectNear(result_coverage.value(), Rect::MakeLTRB(99, 199, 201, 301)));
     }
   }
 }

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), RectNear(), and impeller::Entity::SetTransform().

◆ TEST_P() [458/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithDestinationRect
	)

Definition at line 347 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::kSrcOver);
     std::optional<Rect> result_coverage = result.value().GetCoverage();
     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
     EXPECT_TRUE(result_coverage.has_value());
     EXPECT_TRUE(contents_coverage.has_value());
     if (result_coverage.has_value() && contents_coverage.has_value()) {
       EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
       EXPECT_TRUE(RectNear(result_coverage.value(),
                            Rect::MakeLTRB(49.f, 39.f, 151.f, 141.f)));
     }
   }
 }

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), and RectNear().

◆ TEST_P() [459/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithDestinationRectScaled
	)

Definition at line 381 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::kSrcOver);
     std::optional<Rect> result_coverage = result.value().GetCoverage();
     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
     EXPECT_TRUE(result_coverage.has_value());
     EXPECT_TRUE(contents_coverage.has_value());
     if (result_coverage.has_value() && contents_coverage.has_value()) {
       EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
       // Scaling a blurred entity doesn't seem to scale the blur radius linearly
       // when comparing results with rrect_blur. That's why this is not
       // Rect::MakeXYWH(98.f, 78.f, 204.0f, 204.f).
       EXPECT_TRUE(RectNear(contents_coverage.value(),
                            Rect::MakeXYWH(94.f, 74.f, 212.0f, 212.f)));
     }
   }
 }

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), RectNear(), and impeller::Entity::SetTransform().

◆ TEST_P() [460/545]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithEffectTransform
	)

Definition at line 421 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::kSrcOver);
     std::optional<Rect> result_coverage = result.value().GetCoverage();
     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
     EXPECT_TRUE(result_coverage.has_value());
     EXPECT_TRUE(contents_coverage.has_value());
     if (result_coverage.has_value() && contents_coverage.has_value()) {
       EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
       EXPECT_TRUE(RectNear(contents_coverage.value(),
                            Rect::MakeXYWH(49.f, 39.f, 102.f, 102.f)));
     }
   }
 }

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), and RectNear().

◆ TEST_P() [461/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		CanEmplace
	)

Definition at line 36 of file host_buffer_unittests.cc.

                                    {
   struct Length2 {
     uint8_t pad[2];
   };
   static_assert(sizeof(Length2) == 2u);
  
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   for (size_t i = 0; i < 12500; i++) {
     auto view = buffer->Emplace(Length2{});
     ASSERT_TRUE(view);
     ASSERT_EQ(view.GetRange(), Range(i * sizeof(Length2), 2u));
   }
 }

References impeller::HostBuffer::Create().

◆ TEST_P() [462/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		CanEmplaceWithAlignment
	)

Definition at line 52 of file host_buffer_unittests.cc.

                                                 {
   struct Length2 {
     uint8_t pad[2];
   };
   static_assert(sizeof(Length2) == 2);
   struct alignas(16) Align16 {
     uint8_t pad[2];
   };
   static_assert(alignof(Align16) == 16);
   static_assert(sizeof(Align16) == 16);
  
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
   ASSERT_TRUE(buffer);
  
   {
     auto view = buffer->Emplace(Length2{});
     ASSERT_TRUE(view);
     ASSERT_EQ(view.GetRange(), Range(0u, 2u));
   }
  
   {
     auto view = buffer->Emplace(Align16{});
     ASSERT_TRUE(view);
     ASSERT_EQ(view.GetRange().offset, 16u);
     ASSERT_EQ(view.GetRange().length, 16u);
   }
   {
     auto view = buffer->Emplace(Length2{});
     ASSERT_TRUE(view);
     ASSERT_EQ(view.GetRange(), Range(32u, 2u));
   }
  
   {
     auto view = buffer->Emplace(Align16{});
     ASSERT_TRUE(view);
     ASSERT_EQ(view.GetRange().offset, 48u);
     ASSERT_EQ(view.GetRange().length, 16u);
   }
 }

References impeller::HostBuffer::Create().

◆ TEST_P() [463/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplaceWithFailingAllocationDoesntCrash
	)

Definition at line 221 of file host_buffer_unittests.cc.

                                                                 {
   ScopedValidationDisable disable;
   std::shared_ptr<FailingAllocator> allocator =
       std::make_shared<FailingAllocator>(GetContext()->GetResourceAllocator());
   auto buffer =
       HostBuffer::Create(allocator, GetContext()->GetIdleWaiter(), 256);
  
   auto view = buffer->Emplace(nullptr, kMagicFailingAllocation, 0);
  
   EXPECT_EQ(view.GetBuffer(), nullptr);
   EXPECT_EQ(view.GetRange().offset, 0u);
   EXPECT_EQ(view.GetRange().length, 0u);
 }

References impeller::HostBuffer::Create(), and kMagicFailingAllocation.

◆ TEST_P() [464/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplaceWithProcIsAligned
	)

Definition at line 180 of file host_buffer_unittests.cc.

                                                  {
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   BufferView view = buffer->Emplace(std::array<char, 21>());
   EXPECT_EQ(view.GetRange(), Range(0, 21));
  
   view = buffer->Emplace(64, 16, [](uint8_t*) {});
   EXPECT_EQ(view.GetRange(), Range(32, 64));
 }

References impeller::HostBuffer::Create(), and impeller::BufferView::GetRange().

◆ TEST_P() [465/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplacingLargerThanBlockSizeCreatesOneOffBuffer
	)

Definition at line 135 of file host_buffer_unittests.cc.

                                                                         {
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   // Emplace an amount larger than the block size, to verify that the host
   // buffer does not create a buffer.
   auto buffer_view = buffer->Emplace(nullptr, 1024000 + 10, 0);
  
   EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
   EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
 }

References buffer_view, and impeller::HostBuffer::Create().

◆ TEST_P() [466/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplacingLargerThanBlockSizeCreatesOneOffBufferCallback
	)

Definition at line 121 of file host_buffer_unittests.cc.

                                                                 {
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   // Emplace an amount larger than the block size, to verify that the host
   // buffer does not create a buffer.
   auto buffer_view = buffer->Emplace(1024000 + 10, 0, [](uint8_t* data) {});
  
   EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
   EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
 }

References buffer_view, impeller::HostBuffer::Create(), and data.

◆ TEST_P() [467/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		HostBufferInitialState
	)

Definition at line 93 of file host_buffer_unittests.cc.

                                                {
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
   EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
 }

References impeller::HostBuffer::Create().

◆ TEST_P() [468/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		IdleWaiter
	)

Definition at line 27 of file host_buffer_unittests.cc.

                                    {
   auto mock_idle_waiter = std::make_shared<MockIdleWaiter>();
   {
     auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                      mock_idle_waiter, 256);
     EXPECT_CALL(*mock_idle_waiter, WaitIdle());
   }
 }

References impeller::HostBuffer::Create().

◆ TEST_P() [469/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		ResetIncrementsFrameCounter
	)

Definition at line 102 of file host_buffer_unittests.cc.

                                                     {
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  
   buffer->Reset();
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 1u);
  
   buffer->Reset();
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 2u);
  
   buffer->Reset();
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 3u);
  
   buffer->Reset();
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
 }

References impeller::HostBuffer::Create().

◆ TEST_P() [470/545]

impeller::testing::TEST_P	(	HostBufferTest	,
		UnusedBuffersAreDiscardedWhenResetting
	)

Definition at line 148 of file host_buffer_unittests.cc.

                                                                {
   auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                    GetContext()->GetIdleWaiter(), 256);
  
   // Emplace two large allocations to force the allocation of a second buffer.
   auto buffer_view_a = buffer->Emplace(1020000, 0, [](uint8_t* data) {});
   auto buffer_view_b = buffer->Emplace(1020000, 0, [](uint8_t* data) {});
  
   EXPECT_EQ(buffer->GetStateForTest().current_buffer, 1u);
   EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 2u);
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  
   // Reset until we get back to this frame.
   for (auto i = 0; i < 4; i++) {
     buffer->Reset();
   }
  
   EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
   EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 2u);
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  
   // Now when we reset, the buffer should get dropped.
   // Reset until we get back to this frame.
   for (auto i = 0; i < 4; i++) {
     buffer->Reset();
   }
  
   EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
   EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
   EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
 }

References impeller::HostBuffer::Create(), and data.

◆ TEST_P() [471/545]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageClippedSubpassScale
	)

Definition at line 175 of file matrix_filter_contents_unittests.cc.

                                                             {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   MatrixFilterContents contents;
   contents.SetInputs({FilterInput::Make(texture)});
   contents.SetMatrix(Matrix::MakeScale({3, 3, 1}));
   contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
   contents.SetRenderingMode(
       Entity::RenderingMode::kSubpassAppendSnapshotTransform);
  
   Entity entity;
   entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  
   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));
 }

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::Entity::kSubpassAppendSnapshotTransform, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::MatrixFilterContents::SetRenderingMode(), and impeller::Entity::SetTransform().

◆ TEST_P() [472/545]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageClippedSubpassTranslate
	)

Definition at line 138 of file matrix_filter_contents_unittests.cc.

                                                                 {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   MatrixFilterContents contents;
   contents.SetInputs({FilterInput::Make(texture)});
   contents.SetMatrix(Matrix::MakeTranslation({50, 100, 0}));
   contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
   contents.SetRenderingMode(
       Entity::RenderingMode::kSubpassAppendSnapshotTransform);
  
   Entity entity;
   entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  
   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));
 }

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::Entity::kSubpassAppendSnapshotTransform, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::MatrixFilterContents::SetRenderingMode(), and impeller::Entity::SetTransform().

◆ TEST_P() [473/545]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageIdentity
	)

Definition at line 106 of file matrix_filter_contents_unittests.cc.

                                                                            {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   MatrixFilterContents contents;
   contents.SetInputs({FilterInput::Make(texture)});
  
   Entity entity;
   entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  
   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));
 }

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::FilterInput::Make(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetInputs(), and impeller::Entity::SetTransform().

◆ TEST_P() [474/545]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageScale
	)

Definition at line 158 of file matrix_filter_contents_unittests.cc.

                                                                         {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   MatrixFilterContents contents;
   contents.SetInputs({FilterInput::Make(texture)});
   contents.SetMatrix(Matrix::MakeScale({3, 3, 1}));
   contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
  
   Entity entity;
   entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  
   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));
 }

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), and impeller::Entity::SetTransform().

◆ TEST_P() [475/545]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageSubpassScale
	)

Definition at line 195 of file matrix_filter_contents_unittests.cc.

                                                                                {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   MatrixFilterContents contents;
   contents.SetInputs({FilterInput::Make(texture)});
   contents.SetMatrix(Matrix::MakeScale({3, 3, 1}));
   contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
   contents.SetRenderingMode(
       Entity::RenderingMode::kSubpassPrependSnapshotTransform);
  
   Entity entity;
   entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  
   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));
 }

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::Entity::kSubpassPrependSnapshotTransform, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::MatrixFilterContents::SetRenderingMode(), and impeller::Entity::SetTransform().

◆ TEST_P() [476/545]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageTranslate
	)

Definition at line 121 of file matrix_filter_contents_unittests.cc.

                                                                             {
   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
   MatrixFilterContents contents;
   contents.SetInputs({FilterInput::Make(texture)});
   contents.SetMatrix(Matrix::MakeTranslation({50, 100, 0}));
   contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
  
   Entity entity;
   entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  
   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));
 }

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), and impeller::Entity::SetTransform().

◆ TEST_P() [477/545]

impeller::testing::TEST_P	(	PipelineCacheDataVKPlaygroundTest	,
		CanPersistAndRetrievePipelineCache
	)

Definition at line 117 of file pipeline_cache_data_vk_unittests.cc.

                                                                               {
   fml::ScopedTemporaryDirectory temp_dir;
   const auto& surface_context = SurfaceContextVK::Cast(*GetContext());
   const auto& context_vk = ContextVK::Cast(*surface_context.GetParent());
   const auto& caps = CapabilitiesVK::Cast(*context_vk.GetCapabilities());
  
   {
     auto cache = context_vk.GetDevice().createPipelineCacheUnique({});
     ASSERT_EQ(cache.result, vk::Result::eSuccess);
     ASSERT_FALSE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
     ASSERT_TRUE(PipelineCacheDataPersist(
         temp_dir.fd(), caps.GetPhysicalDeviceProperties(), cache.value));
   }
   ASSERT_TRUE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
  
   auto mapping = PipelineCacheDataRetrieve(temp_dir.fd(),
                                            caps.GetPhysicalDeviceProperties());
   ASSERT_NE(mapping, nullptr);
   // Assert that the utility has stripped away the cache header giving us clean
   // pipeline cache bootstrap information.
   vk::PipelineCacheHeaderVersionOne vk_cache_header;
   ASSERT_GE(mapping->GetSize(), sizeof(vk_cache_header));
   std::memcpy(&vk_cache_header, mapping->GetMapping(), sizeof(vk_cache_header));
   ASSERT_EQ(vk_cache_header.headerVersion,
             vk::PipelineCacheHeaderVersion::eOne);
 }

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), impeller::BackendCast< ContextVK, Context >::Cast(), impeller::BackendCast< SurfaceContextVK, Context >::Cast(), impeller::PipelineCacheDataPersist(), and impeller::PipelineCacheDataRetrieve().

◆ TEST_P() [478/545]

impeller::testing::TEST_P	(	PipelineCacheDataVKPlaygroundTest	,
		IntegrityChecksArePerformedOnPersistedData
	)

Definition at line 144 of file pipeline_cache_data_vk_unittests.cc.

                                                    {
   fml::ScopedTemporaryDirectory temp_dir;
   const auto& surface_context = SurfaceContextVK::Cast(*GetContext());
   const auto& context_vk = ContextVK::Cast(*surface_context.GetParent());
   const auto& caps = CapabilitiesVK::Cast(*context_vk.GetCapabilities());
  
   {
     auto cache = context_vk.GetDevice().createPipelineCacheUnique({});
     ASSERT_EQ(cache.result, vk::Result::eSuccess);
     ASSERT_FALSE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
     ASSERT_TRUE(PipelineCacheDataPersist(
         temp_dir.fd(), caps.GetPhysicalDeviceProperties(), cache.value));
   }
   ASSERT_TRUE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
   auto incompatible_caps = caps.GetPhysicalDeviceProperties();
   // Simulate a driver version bump.
   incompatible_caps.driverVersion =
       caps.GetPhysicalDeviceProperties().driverVersion + 1u;
   auto mapping = PipelineCacheDataRetrieve(temp_dir.fd(), incompatible_caps);
   ASSERT_EQ(mapping, nullptr);
 }

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), impeller::BackendCast< ContextVK, Context >::Cast(), impeller::BackendCast< SurfaceContextVK, Context >::Cast(), impeller::PipelineCacheDataPersist(), and impeller::PipelineCacheDataRetrieve().

◆ TEST_P() [479/545]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanCreateRenderPassAndSubmit
	)

Definition at line 300 of file renderer_dart_unittests.cc.

                                                        {
   ASSERT_TRUE(RenderDartToPlayground("canCreateRenderPassAndSubmit"));
 }

◆ TEST_P() [480/545]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanCreateShaderLibrary
	)

Definition at line 292 of file renderer_dart_unittests.cc.

                                                  {
   ASSERT_TRUE(RunDartFunction("canCreateShaderLibrary"));
 }

◆ TEST_P() [481/545]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanInstantiateFlutterGPUContext
	)

These test entries correspond to Dart functions located in flutter/impeller/fixtures/dart_tests.dart

Definition at line 288 of file renderer_dart_unittests.cc.

                                                           {
   ASSERT_TRUE(RunDartFunction("instantiateDefaultContext"));
 }

◆ TEST_P() [482/545]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanReflectUniformStructs
	)

Definition at line 296 of file renderer_dart_unittests.cc.

                                                    {
   ASSERT_TRUE(RunDartFunction("canReflectUniformStructs"));
 }

◆ TEST_P() [483/545]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanRunDartInPlaygroundFrame
	)

Definition at line 273 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() [484/545]

impeller::testing::TEST_P	(	RendererTest	,
		ArrayUniforms
	)

Definition at line 1029 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(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kCount4, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Color::MakeRGBA8(), impeller::Matrix::MakeScale(), and x.

◆ TEST_P() [485/545]

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(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
  
   // 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(), context->GetIdleWaiter(),
         context->GetCapabilities()->GetMinimumUniformAlignment());
     FS::BindFragInfo(pass, host_buffer->EmplaceUniform(frag_info));
  
     return pass.Draw().ok();
   };
   OpenPlaygroundHere(callback);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::Color::Blue(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Color::Green(), impeller::kCount4, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), and impeller::Color::Red().

◆ TEST_P() [486/545]

impeller::testing::TEST_P	(	RendererTest	,
		BindingNullTexturesDoesNotCrash
	)

Definition at line 1630 of file renderer_unittests.cc.

                                                       {
   using FS = BoxFadeFragmentShader;
  
   auto context = GetContext();
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   auto command_buffer = context->CreateCommandBuffer();
  
   RenderTargetAllocator allocator(context->GetResourceAllocator());
   RenderTarget target = allocator.CreateOffscreen(*context, {1, 1}, 1);
  
   auto pass = command_buffer->CreateRenderPass(target);
   EXPECT_FALSE(FS::BindContents2(*pass, nullptr, sampler));
 }

References impeller::RenderTargetAllocator::CreateOffscreen().

◆ TEST_P() [487/545]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebuffer
	)

Definition at line 17 of file render_pass_cache_unittests.cc.

                                                      {
   if (GetBackend() != PlaygroundBackend::kVulkan) {
     GTEST_SKIP() << "Test only applies to Vulkan";
   }
  
   auto allocator = std::make_shared<RenderTargetAllocator>(
       GetContext()->GetResourceAllocator());
  
   RenderTarget render_target =
       allocator->CreateOffscreenMSAA(*GetContext(), {100, 100}, 1);
   std::shared_ptr<Texture> resolve_texture =
       render_target.GetColorAttachment(0).resolve_texture;
   TextureVK& texture_vk = TextureVK::Cast(*resolve_texture);
  
   EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
             nullptr);
   EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
             nullptr);
  
   auto buffer = GetContext()->CreateCommandBuffer();
   auto render_pass = buffer->CreateRenderPass(render_target);
  
   EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
             nullptr);
   EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
             nullptr);
  
   render_pass->EncodeCommands();
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer}).ok());
  
   // Can be reused without error.
   auto buffer_2 = GetContext()->CreateCommandBuffer();
   auto render_pass_2 = buffer_2->CreateRenderPass(render_target);
  
   EXPECT_TRUE(render_pass_2->EncodeCommands());
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_2}).ok());
 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::FramebufferAndRenderPass::framebuffer, impeller::TextureVK::GetCachedFrameData(), impeller::RenderTarget::GetColorAttachment(), impeller::kCount4, impeller::kVulkan, impeller::FramebufferAndRenderPass::render_pass, and impeller::Attachment::resolve_texture.

◆ TEST_P() [488/545]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebufferMixed
	)

Definition at line 93 of file render_pass_cache_unittests.cc.

                                                           {
   if (GetBackend() != PlaygroundBackend::kVulkan) {
     GTEST_SKIP() << "Test only applies to Vulkan";
   }
  
   auto allocator = std::make_shared<RenderTargetAllocator>(
       GetContext()->GetResourceAllocator());
  
   RenderTarget render_target =
       allocator->CreateOffscreenMSAA(*GetContext(), {100, 100}, 1);
   std::shared_ptr<Texture> resolve_texture =
       render_target.GetColorAttachment(0).resolve_texture;
   TextureVK& texture_vk = TextureVK::Cast(*resolve_texture);
  
   EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
             nullptr);
   EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
             nullptr);
  
   auto buffer = GetContext()->CreateCommandBuffer();
   auto render_pass = buffer->CreateRenderPass(render_target);
  
   EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
             nullptr);
   EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
             nullptr);
  
   render_pass->EncodeCommands();
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer}).ok());
  
   // Can be reused without error.
   auto buffer_2 = GetContext()->CreateCommandBuffer();
   auto render_pass_2 = buffer_2->CreateRenderPass(render_target);
  
   EXPECT_TRUE(render_pass_2->EncodeCommands());
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_2}).ok());
  
   // Now switch to single sample count and demonstrate no validation errors.
   {
     RenderTarget other_target;
     ColorAttachment color0;
     color0.load_action = LoadAction::kLoad;
     color0.store_action = StoreAction::kStore;
     color0.texture = resolve_texture;
     other_target.SetColorAttachment(color0, 0);
     other_target.SetDepthAttachment(std::nullopt);
     other_target.SetStencilAttachment(std::nullopt);
  
     EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
               nullptr);
     EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
               nullptr);
  
     auto buffer_3 = GetContext()->CreateCommandBuffer();
     auto render_pass_3 = buffer_3->CreateRenderPass(other_target);
  
     EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
               nullptr);
     EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
               nullptr);
  
     EXPECT_TRUE(render_pass_3->EncodeCommands());
     EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_3}).ok());
   }
 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::FramebufferAndRenderPass::framebuffer, impeller::TextureVK::GetCachedFrameData(), impeller::RenderTarget::GetColorAttachment(), impeller::kCount1, impeller::kCount4, impeller::kLoad, impeller::kStore, impeller::kVulkan, impeller::Attachment::load_action, impeller::FramebufferAndRenderPass::render_pass, impeller::Attachment::resolve_texture, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetDepthAttachment(), impeller::RenderTarget::SetStencilAttachment(), impeller::Attachment::store_action, and impeller::Attachment::texture.

◆ TEST_P() [489/545]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebufferNonMSAA
	)

Definition at line 55 of file render_pass_cache_unittests.cc.

                                                             {
   if (GetBackend() != PlaygroundBackend::kVulkan) {
     GTEST_SKIP() << "Test only applies to Vulkan";
   }
  
   auto allocator = std::make_shared<RenderTargetAllocator>(
       GetContext()->GetResourceAllocator());
  
   RenderTarget render_target =
       allocator->CreateOffscreen(*GetContext(), {100, 100}, 1);
   std::shared_ptr<Texture> color_texture =
       render_target.GetColorAttachment(0).texture;
   TextureVK& texture_vk = TextureVK::Cast(*color_texture);
  
   EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
             nullptr);
   EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
             nullptr);
  
   auto buffer = GetContext()->CreateCommandBuffer();
   auto render_pass = buffer->CreateRenderPass(render_target);
  
   EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
             nullptr);
   EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
             nullptr);
  
   render_pass->EncodeCommands();
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer}).ok());
  
   // Can be reused without error.
   auto buffer_2 = GetContext()->CreateCommandBuffer();
   auto render_pass_2 = buffer_2->CreateRenderPass(render_target);
  
   EXPECT_TRUE(render_pass_2->EncodeCommands());
   EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_2}).ok());
 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::FramebufferAndRenderPass::framebuffer, impeller::TextureVK::GetCachedFrameData(), impeller::RenderTarget::GetColorAttachment(), impeller::kCount1, impeller::kVulkan, impeller::FramebufferAndRenderPass::render_pass, and impeller::Attachment::texture.

◆ TEST_P() [490/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanBlitTextureToBuffer
	)

Definition at line 642 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);
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   TextureDescriptor texture_desc;
   texture_desc.storage_mode = StorageMode::kHostVisible;
   texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
   texture_desc.size = bridge->GetTextureDescriptor().size;
   texture_desc.mip_count = 1u;
   texture_desc.usage = TextureUsage::kRenderTarget |
                        TextureUsage::kShaderWrite | TextureUsage::kShaderRead;
   DeviceBufferDescriptor device_buffer_desc;
   device_buffer_desc.storage_mode = StorageMode::kHostVisible;
   device_buffer_desc.size =
       bridge->GetTextureDescriptor().GetByteSizeOfBaseMipLevel();
   auto device_buffer =
       context->GetResourceAllocator()->CreateBuffer(device_buffer_desc);
  
   // Vertex buffer.
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   vertex_builder.SetLabel("Box");
   auto size = Point(boston->GetSize());
   vertex_builder.AddVertices({
       {{0, 0}, {0.0, 0.0}},            // 1
       {{size.x, 0}, {1.0, 0.0}},       // 2
       {{size.x, size.y}, {1.0, 1.0}},  // 3
       {{0, 0}, {0.0, 0.0}},            // 1
       {{size.x, size.y}, {1.0, 1.0}},  // 3
       {{0, size.y}, {0.0, 1.0}},       // 4
   });
   auto vertex_buffer =
       vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
   ASSERT_TRUE(vertex_buffer);
  
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   Playground::RenderCallback callback = [&](RenderTarget& render_target) {
     {
       auto buffer = context->CreateCommandBuffer();
       if (!buffer) {
         return false;
       }
       buffer->SetLabel("Playground Command Buffer");
       auto pass = buffer->CreateBlitPass();
       if (!pass) {
         return false;
       }
       pass->SetLabel("Playground Blit Pass");
  
       // Blit `bridge` to the top left corner of the texture.
       pass->AddCopy(bridge, device_buffer);
       pass->EncodeCommands();
  
       if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
         return false;
       }
     }
  
     {
       auto buffer = context->CreateCommandBuffer();
       if (!buffer) {
         return false;
       }
       buffer->SetLabel("Playground Command Buffer");
  
       auto pass = buffer->CreateRenderPass(render_target);
       if (!pass) {
         return false;
       }
       pass->SetLabel("Playground Render Pass");
       {
         pass->SetCommandLabel("Image");
         pass->SetPipeline(mipmaps_pipeline);
         pass->SetVertexBuffer(vertex_buffer);
  
         VS::FrameInfo frame_info;
         EXPECT_EQ(pass->GetOrthographicTransform(),
                   Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
         frame_info.mvp = pass->GetOrthographicTransform() *
                          Matrix::MakeScale(GetContentScale());
         VS::BindFrameInfo(*pass, host_buffer->EmplaceUniform(frame_info));
  
         FS::FragInfo frag_info;
         frag_info.lod = 0;
         FS::BindFragInfo(*pass, host_buffer->EmplaceUniform(frag_info));
  
         raw_ptr<const Sampler> sampler =
             context->GetSamplerLibrary()->GetSampler({});
         auto buffer_view = DeviceBuffer::AsBufferView(device_buffer);
         auto texture =
             context->GetResourceAllocator()->CreateTexture(texture_desc);
         if (!texture->SetContents(device_buffer->OnGetContents(),
                                   buffer_view.GetRange().length)) {
           VALIDATION_LOG << "Could not upload texture to device memory";
           return false;
         }
         FS::BindTex(*pass, texture, sampler);
  
         pass->Draw().ok();
       }
       pass->EncodeCommands();
       if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
         return false;
       }
     }
     host_buffer->Reset();
     return true;
   };
   OpenPlaygroundHere(callback);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::DeviceBuffer::AsBufferView(), buffer_view, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::kCount4, impeller::kHostVisible, impeller::kOpenGLES, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::kShaderWrite, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::TextureDescriptor::mip_count, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, impeller::TextureDescriptor::storage_mode, impeller::TextureDescriptor::usage, and VALIDATION_LOG.

◆ TEST_P() [491/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanBlitTextureToTexture
	)

Definition at line 530 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);
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   // Vertex buffer.
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   vertex_builder.SetLabel("Box");
   auto size = Point(boston->GetSize());
   vertex_builder.AddVertices({
       {{0, 0}, {0.0, 0.0}},            // 1
       {{size.x, 0}, {1.0, 0.0}},       // 2
       {{size.x, size.y}, {1.0, 1.0}},  // 3
       {{0, 0}, {0.0, 0.0}},            // 1
       {{size.x, size.y}, {1.0, 1.0}},  // 3
       {{0, size.y}, {0.0, 1.0}},       // 4
   });
   auto vertex_buffer =
       vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
   ASSERT_TRUE(vertex_buffer);
  
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   Playground::RenderCallback callback = [&](RenderTarget& render_target) {
     auto buffer = context->CreateCommandBuffer();
     if (!buffer) {
       return false;
     }
     buffer->SetLabel("Playground Command Buffer");
  
     {
       auto pass = buffer->CreateBlitPass();
       if (!pass) {
         return false;
       }
       pass->SetLabel("Playground Blit Pass");
  
       // Blit `bridge` to the top left corner of the texture.
       pass->AddCopy(bridge, texture);
  
       if (!pass->EncodeCommands()) {
         return false;
       }
     }
  
     {
       auto pass = buffer->CreateRenderPass(render_target);
       if (!pass) {
         return false;
       }
       pass->SetLabel("Playground Render Pass");
       {
         pass->SetCommandLabel("Image");
         pass->SetPipeline(mipmaps_pipeline);
         pass->SetVertexBuffer(vertex_buffer);
  
         VS::FrameInfo frame_info;
         EXPECT_EQ(pass->GetOrthographicTransform(),
                   Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
         frame_info.mvp = pass->GetOrthographicTransform() *
                          Matrix::MakeScale(GetContentScale());
         VS::BindFrameInfo(*pass, 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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::kCount4, impeller::kHostVisible, impeller::kOpenGLES, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::TextureDescriptor::mip_count, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and impeller::TextureDescriptor::usage.

◆ TEST_P() [492/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanCreateBoxPrimitive
	)

Definition at line 53 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);
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kCount4, impeller::kFill, impeller::kLine, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [493/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanGenerateMipmaps
	)

Definition at line 773 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(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   Playground::RenderCallback callback = [&](RenderTarget& render_target) {
     const char* mip_filter_names[] = {"Base", "Nearest", "Linear"};
     const MipFilter mip_filters[] = {MipFilter::kBase, MipFilter::kNearest,
                                      MipFilter::kLinear};
     const char* min_filter_names[] = {"Nearest", "Linear"};
     const MinMagFilter min_filters[] = {MinMagFilter::kNearest,
                                         MinMagFilter::kLinear};
  
     // UI state.
     static int selected_mip_filter = 1;
     static int selected_min_filter = 0;
     static float lod = 4.5;
  
     ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
     ImGui::Combo("Mip filter", &selected_mip_filter, mip_filter_names,
                  sizeof(mip_filter_names) / sizeof(char*));
     ImGui::Combo("Min filter", &selected_min_filter, min_filter_names,
                  sizeof(min_filter_names) / sizeof(char*));
     ImGui::SliderFloat("LOD", &lod, 0, boston->GetMipCount() - 1);
     ImGui::End();
  
     auto buffer = context->CreateCommandBuffer();
     if (!buffer) {
       return false;
     }
     buffer->SetLabel("Playground Command Buffer");
  
     if (first_frame) {
       auto pass = buffer->CreateBlitPass();
       if (!pass) {
         return false;
       }
       pass->SetLabel("Playground Blit Pass");
  
       pass->GenerateMipmap(boston, "Boston Mipmap");
  
       pass->EncodeCommands();
     }
  
     first_frame = false;
  
     {
       auto pass = buffer->CreateRenderPass(render_target);
       if (!pass) {
         return false;
       }
       pass->SetLabel("Playground Render Pass");
       {
         pass->SetCommandLabel("Image LOD");
         pass->SetPipeline(mipmaps_pipeline);
         pass->SetVertexBuffer(vertex_buffer);
  
         VS::FrameInfo frame_info;
         EXPECT_EQ(pass->GetOrthographicTransform(),
                   Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
         frame_info.mvp = pass->GetOrthographicTransform() *
                          Matrix::MakeScale(GetContentScale());
         VS::BindFrameInfo(*pass, 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];
         raw_ptr<const Sampler> sampler =
             context->GetSamplerLibrary()->GetSampler(sampler_desc);
         FS::BindTex(*pass, boston, sampler);
  
         pass->Draw();
       }
       pass->EncodeCommands();
     }
  
     if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
       return false;
     }
     host_buffer->Reset();
     return true;
   };
   OpenPlaygroundHere(callback);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kBase, impeller::kCount4, impeller::kLinear, impeller::kNearest, impeller::kOpenGLES, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::SamplerDescriptor::min_filter, impeller::SamplerDescriptor::mip_filter, and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [494/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanLookupRenderTargetProperties
	)

Definition at line 1378 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() [495/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderInstanced
	)

Definition at line 471 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(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   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;
   }));
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::RenderPass::Draw(), impeller::RenderPass::GetOrthographicTransform(), impeller::RenderPass::GetRenderTargetSize(), impeller::kCount4, impeller::kOpenGLES, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::Color::Random(), impeller::RenderPass::SetCommandLabel(), impeller::RenderPass::SetInstanceCount(), impeller::RenderPass::SetPipeline(), and impeller::RenderPass::SetVertexBuffer().

◆ TEST_P() [496/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderMultiplePrimitives
	)

Definition at line 293 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);
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kCount4, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [497/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderPerspectiveCube
	)

Definition at line 180 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->ClearStencilAttachments();
  
   // Setup the vertex layout to take two bindings. The first for positions and
   // the second for colors.
   auto vertex_desc = std::make_shared<VertexDescriptor>();
   ShaderStageIOSlot position_slot = VS::kInputPosition;
   ShaderStageIOSlot color_slot = VS::kInputColor;
   position_slot.binding = 0;
   position_slot.offset = 0;
   color_slot.binding = 1;
   color_slot.offset = 0;
   const std::vector<ShaderStageIOSlot> io_slots = {position_slot, color_slot};
   const std::vector<ShaderStageBufferLayout> layouts = {
       ShaderStageBufferLayout{.stride = 12u, .binding = 0},
       ShaderStageBufferLayout{.stride = 16u, .binding = 1}};
   vertex_desc->RegisterDescriptorSetLayouts(VS::kDescriptorSetLayouts);
   vertex_desc->RegisterDescriptorSetLayouts(FS::kDescriptorSetLayouts);
   vertex_desc->SetStageInputs(io_slots, layouts);
   desc->SetVertexDescriptor(std::move(vertex_desc));
   auto pipeline =
       context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
   ASSERT_TRUE(pipeline);
  
   struct Cube {
     Vector3 positions[8] = {
         // -Z
         {-1, -1, -1},
         {1, -1, -1},
         {1, 1, -1},
         {-1, 1, -1},
         // +Z
         {-1, -1, 1},
         {1, -1, 1},
         {1, 1, 1},
         {-1, 1, 1},
     };
     Color colors[8] = {
         Color::Red(),   Color::Yellow(), Color::Green(), Color::Blue(),
         Color::Green(), Color::Blue(),   Color::Red(),   Color::Yellow(),
     };
     uint16_t indices[36] = {
         1, 5, 2, 2, 5, 6,  // +X
         4, 0, 7, 7, 0, 3,  // -X
         4, 5, 0, 0, 5, 1,  // +Y
         3, 2, 7, 7, 2, 6,  // -Y
         5, 4, 6, 6, 4, 7,  // +Z
         0, 1, 3, 3, 1, 2,  // -Z
     };
   } cube;
  
   auto device_buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
       reinterpret_cast<uint8_t*>(&cube), sizeof(cube));
  
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   Vector3 euler_angles;
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   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);
  
     std::array<BufferView, 2> vertex_buffers = {
         BufferView(device_buffer,
                    Range(offsetof(Cube, positions), sizeof(Cube::positions))),
         BufferView(device_buffer,
                    Range(offsetof(Cube, colors), sizeof(Cube::colors))),
     };
  
     BufferView index_buffer(
         device_buffer, Range(offsetof(Cube, indices), sizeof(Cube::indices)));
     pass.SetVertexBuffer(vertex_buffers.data(), vertex_buffers.size());
     pass.SetElementCount(36);
     pass.SetIndexBuffer(index_buffer, IndexType::k16bit);
  
     VS::UniformBuffer uniforms;
     Scalar time = GetSecondsElapsed();
     euler_angles = Vector3(0.19 * time, 0.7 * time, 0.43 * time);
  
     uniforms.mvp =
         Matrix::MakePerspective(fov_y, pass.GetRenderTargetSize(), 0, 10) *
         Matrix::MakeTranslation({0, 0, distance}) *
         Matrix::MakeRotationX(Radians(euler_angles.x)) *
         Matrix::MakeRotationY(Radians(euler_angles.y)) *
         Matrix::MakeRotationZ(Radians(euler_angles.z));
     VS::BindUniformBuffer(pass, host_buffer->EmplaceUniform(uniforms));
  
     host_buffer->Reset();
     return pass.Draw().ok();
   };
   OpenPlaygroundHere(callback);
 }

References impeller::ShaderStageIOSlot::binding, impeller::Color::Blue(), impeller::HostBuffer::Create(), impeller::Degrees::degrees, impeller::saturated::distance, impeller::Color::Green(), impeller::k16bit, impeller::kBackFace, impeller::kCount4, impeller::kCounterClockwise, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakePerspective(), impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), impeller::ShaderStageIOSlot::offset, impeller::Color::Red(), impeller::ShaderStageBufferLayout::stride, impeller::Vector3::x, impeller::Vector3::y, impeller::Color::Yellow(), and impeller::Vector3::z.

◆ TEST_P() [498/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderToTexture
	)

Definition at line 367 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(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
  
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   vertex_builder.SetLabel("Box");
   vertex_builder.AddVertices({
       {{100, 100, 0.0}, {0.0, 0.0}},  // 1
       {{800, 100, 0.0}, {1.0, 0.0}},  // 2
       {{800, 800, 0.0}, {1.0, 1.0}},  // 3
       {{100, 100, 0.0}, {0.0, 0.0}},  // 1
       {{800, 800, 0.0}, {1.0, 1.0}},  // 3
       {{100, 800, 0.0}, {0.0, 1.0}},  // 4
   });
   auto vertex_buffer =
       vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
   ASSERT_TRUE(vertex_buffer);
  
   auto bridge = CreateTextureForFixture("bay_bridge.jpg");
   auto boston = CreateTextureForFixture("boston.jpg");
   ASSERT_TRUE(bridge && boston);
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   std::shared_ptr<RenderPass> r2t_pass;
   auto cmd_buffer = context->CreateCommandBuffer();
   ASSERT_TRUE(cmd_buffer);
   {
     ColorAttachment color0;
     color0.load_action = LoadAction::kClear;
     color0.store_action = StoreAction::kStore;
  
     TextureDescriptor texture_descriptor;
     ASSERT_NE(pipeline_desc->GetColorAttachmentDescriptor(0u), nullptr);
     texture_descriptor.format =
         pipeline_desc->GetColorAttachmentDescriptor(0u)->format;
     texture_descriptor.storage_mode = StorageMode::kHostVisible;
     texture_descriptor.size = {400, 400};
     texture_descriptor.mip_count = 1u;
     texture_descriptor.usage = TextureUsage::kRenderTarget;
  
     color0.texture =
         context->GetResourceAllocator()->CreateTexture(texture_descriptor);
  
     ASSERT_TRUE(color0.IsValid());
  
     color0.texture->SetLabel("r2t_target");
  
     StencilAttachment stencil0;
     stencil0.load_action = LoadAction::kClear;
     stencil0.store_action = StoreAction::kDontCare;
     TextureDescriptor stencil_texture_desc;
     stencil_texture_desc.storage_mode = StorageMode::kDeviceTransient;
     stencil_texture_desc.size = texture_descriptor.size;
     stencil_texture_desc.format = PixelFormat::kS8UInt;
     stencil_texture_desc.usage = TextureUsage::kRenderTarget;
     stencil0.texture =
         context->GetResourceAllocator()->CreateTexture(stencil_texture_desc);
  
     RenderTarget r2t_desc;
     r2t_desc.SetColorAttachment(color0, 0u);
     r2t_desc.SetStencilAttachment(stencil0);
     r2t_pass = cmd_buffer->CreateRenderPass(r2t_desc);
     ASSERT_TRUE(r2t_pass && r2t_pass->IsValid());
   }
  
   r2t_pass->SetCommandLabel("Box");
   r2t_pass->SetPipeline(box_pipeline);
   r2t_pass->SetVertexBuffer(vertex_buffer);
  
   FS::FrameInfo frame_info;
   frame_info.current_time = GetSecondsElapsed();
   frame_info.cursor_position = GetCursorPosition();
   frame_info.window_size.x = GetWindowSize().width;
   frame_info.window_size.y = GetWindowSize().height;
  
   FS::BindFrameInfo(*r2t_pass, 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());
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::Attachment::IsValid(), impeller::kClear, impeller::kCount1, impeller::kDeviceTransient, impeller::kDontCare, impeller::kHostVisible, impeller::kRenderTarget, impeller::kS8UInt, impeller::kStore, impeller::Attachment::load_action, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeTranslation(), impeller::TextureDescriptor::mip_count, impeller::RenderTarget::SetColorAttachment(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::RenderTarget::SetStencilAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, and impeller::TextureDescriptor::usage.

◆ TEST_P() [499/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanSepiaToneThenSwizzleWithSubpasses
	)

Definition at line 1521 of file renderer_unittests.cc.

                                                            {
   // 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(), context->GetIdleWaiter(),
         context->GetCapabilities()->GetMinimumUniformAlignment());
  
     // 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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Matrix::MakeOrthographic(), and impeller::Matrix::MakeScale().

◆ TEST_P() [500/545]

impeller::testing::TEST_P	(	RendererTest	,
		CanSepiaToneWithSubpasses
	)

Definition at line 1431 of file renderer_unittests.cc.

                                                 {
   // Define shader types
   using TextureVS = TextureVertexShader;
   using TextureFS = TextureFragmentShader;
  
   using SepiaVS = SepiaVertexShader;
   using SepiaFS = SepiaFragmentShader;
  
   auto context = GetContext();
   ASSERT_TRUE(context);
  
   if (!context->GetCapabilities()->SupportsFramebufferFetch()) {
     GTEST_SKIP() << "This test uses framebuffer fetch and the backend doesn't "
                     "support it.";
     return;
   }
  
   // Create pipelines.
   auto texture_pipeline = CreateDefaultPipeline<TextureVS, TextureFS>(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(), context->GetIdleWaiter(),
         context->GetCapabilities()->GetMinimumUniformAlignment());
  
     // Draw the texture.
     {
       pass.SetPipeline(texture_pipeline);
       pass.SetVertexBuffer(texture_vtx_builder.CreateVertexBuffer(
           *context->GetResourceAllocator()));
       TextureVS::UniformBuffer uniforms;
       uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                      Matrix::MakeScale(GetContentScale());
       TextureVS::BindUniformBuffer(pass, buffer->EmplaceUniform(uniforms));
       TextureFS::BindTextureContents(pass, boston, sampler);
       if (!pass.Draw().ok()) {
         return false;
       }
     }
  
     // Draw the sepia toner.
     {
       pass.SetPipeline(sepia_pipeline);
       pass.SetVertexBuffer(sepia_vtx_builder.CreateVertexBuffer(
           *context->GetResourceAllocator()));
       SepiaVS::UniformBuffer uniforms;
       uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                      Matrix::MakeScale(GetContentScale());
       SepiaVS::BindUniformBuffer(pass, buffer->EmplaceUniform(uniforms));
       if (!pass.Draw().ok()) {
         return false;
       }
     }
  
     return true;
   };
   OpenPlaygroundHere(callback);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Matrix::MakeOrthographic(), and impeller::Matrix::MakeScale().

◆ TEST_P() [501/545]

impeller::testing::TEST_P	(	RendererTest	,
		DefaultIndexBehavior
	)

Definition at line 1147 of file renderer_unittests.cc.

                                            {
   using VS = BoxFadeVertexShader;
  
   // Do not create any index buffer if no indices were provided.
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   ASSERT_EQ(vertex_builder.GetIndexType(), IndexType::kNone);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetIndexType(), and impeller::kNone.

◆ TEST_P() [502/545]

impeller::testing::TEST_P	(	RendererTest	,
		DefaultIndexSize
	)

Definition at line 1137 of file renderer_unittests.cc.

                                        {
   using VS = BoxFadeVertexShader;
  
   // Default to 16bit index buffer size, as this is a reasonable default and
   // supported on all backends without extensions.
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   vertex_builder.AppendIndex(0u);
   ASSERT_EQ(vertex_builder.GetIndexType(), IndexType::k16bit);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AppendIndex(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetIndexType(), and impeller::k16bit.

◆ TEST_P() [503/545]

impeller::testing::TEST_P	(	RendererTest	,
		InactiveUniforms
	)

Definition at line 1088 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(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Color::Green(), impeller::kCount4, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), and impeller::Color::Red().

◆ TEST_P() [504/545]

impeller::testing::TEST_P	(	RendererTest	,
		Planet
	)

Definition at line 961 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(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
  
   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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kCount4, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), and impeller::Matrix::MakeOrthographic().

◆ TEST_P() [505/545]

impeller::testing::TEST_P	(	RendererTest	,
		RenderTargetCreateOffscreenMSAASetsDefaultDepthStencilFormat
	)

Definition at line 1398 of file renderer_unittests.cc.

                                                                      {
   auto context = GetContext();
   auto render_target_cache = std::make_shared<RenderTargetAllocator>(
       GetContext()->GetResourceAllocator());
  
   RenderTarget render_target = render_target_cache->CreateOffscreenMSAA(
       *context, {100, 100}, /*mip_count=*/1);
   EXPECT_EQ(render_target.GetDepthAttachment()
                 ->texture->GetTextureDescriptor()
                 .format,
             GetContext()->GetCapabilities()->GetDefaultDepthStencilFormat());
 }

References impeller::RenderTarget::GetDepthAttachment().

◆ TEST_P() [506/545]

impeller::testing::TEST_P	(	RendererTest	,
		StencilMask
	)

Definition at line 1225 of file renderer_unittests.cc.

                                   {
   using VS = BoxFadeVertexShader;
   using FS = BoxFadeFragmentShader;
   auto context = GetContext();
   ASSERT_TRUE(context);
   using BoxFadePipelineBuilder = PipelineBuilder<VS, FS>;
   auto desc = BoxFadePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
   ASSERT_TRUE(desc.has_value());
  
   // Vertex buffer.
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   vertex_builder.SetLabel("Box");
   vertex_builder.AddVertices({
       {{100, 100, 0.0}, {0.0, 0.0}},  // 1
       {{800, 100, 0.0}, {1.0, 0.0}},  // 2
       {{800, 800, 0.0}, {1.0, 1.0}},  // 3
       {{100, 100, 0.0}, {0.0, 0.0}},  // 1
       {{800, 800, 0.0}, {1.0, 1.0}},  // 3
       {{100, 800, 0.0}, {0.0, 1.0}},  // 4
   });
   auto vertex_buffer =
       vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
   ASSERT_TRUE(vertex_buffer);
  
   desc->SetSampleCount(SampleCount::kCount4);
   desc->SetStencilAttachmentDescriptors(std::nullopt);
  
   auto bridge = CreateTextureForFixture("bay_bridge.jpg");
   auto boston = CreateTextureForFixture("boston.jpg");
   ASSERT_TRUE(bridge && boston);
   raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
   ASSERT_TRUE(sampler);
  
   static bool mirror = false;
   static int stencil_reference_write = 0xFF;
   static int stencil_reference_read = 0x1;
   std::vector<uint8_t> stencil_contents;
   static int last_stencil_contents_reference_value = 0;
   static int current_front_compare =
       CompareFunctionUI().IndexOf(CompareFunction::kLessEqual);
   static int current_back_compare =
       CompareFunctionUI().IndexOf(CompareFunction::kLessEqual);
  
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
   Playground::RenderCallback callback = [&](RenderTarget& render_target) {
     auto buffer = context->CreateCommandBuffer();
     if (!buffer) {
       return false;
     }
     buffer->SetLabel("Playground Command Buffer");
  
     {
       // Configure the stencil attachment for the test.
       RenderTarget::AttachmentConfig stencil_config;
       stencil_config.load_action = LoadAction::kLoad;
       stencil_config.store_action = StoreAction::kDontCare;
       stencil_config.storage_mode = StorageMode::kHostVisible;
       render_target.SetupDepthStencilAttachments(
           *context, *context->GetResourceAllocator(),
           render_target.GetRenderTargetSize(), true, "stencil", stencil_config);
       // Fill the stencil buffer with an checkerboard pattern.
       const auto target_width = render_target.GetRenderTargetSize().width;
       const auto target_height = render_target.GetRenderTargetSize().height;
       const size_t target_size = target_width * target_height;
       if (stencil_contents.size() != target_size ||
           last_stencil_contents_reference_value != stencil_reference_write) {
         stencil_contents.resize(target_size);
         last_stencil_contents_reference_value = stencil_reference_write;
         for (int y = 0; y < target_height; y++) {
           for (int x = 0; x < target_width; x++) {
             const auto index = y * target_width + x;
             const auto kCheckSize = 64;
             const auto value =
                 (((y / kCheckSize) + (x / kCheckSize)) % 2 == 0) *
                 stencil_reference_write;
             stencil_contents[index] = value;
           }
         }
       }
       if (!render_target.GetStencilAttachment()->texture->SetContents(
               stencil_contents.data(), stencil_contents.size(), 0, false)) {
         VALIDATION_LOG << "Could not upload stencil contents to device memory";
         return false;
       }
       auto pass = buffer->CreateRenderPass(render_target);
       if (!pass) {
         return false;
       }
       pass->SetLabel("Stencil Buffer");
       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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), CompareFunctionUI(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::testing::CompareFunctionUIData::FunctionOf(), impeller::testing::CompareFunctionUIData::IndexOf(), impeller::kCount4, impeller::kDontCare, impeller::kHostVisible, impeller::kLessEqual, impeller::kLoad, impeller::RenderTarget::AttachmentConfig::load_action, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::StencilAttachmentDescriptor::stencil_compare, impeller::RenderTarget::AttachmentConfig::storage_mode, impeller::RenderTarget::AttachmentConfig::store_action, VALIDATION_LOG, value, and x.

◆ TEST_P() [507/545]

impeller::testing::TEST_P	(	RendererTest	,
		TheImpeller
	)

Definition at line 897 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;
   raw_ptr<const Sampler> noise_sampler =
       context->GetSamplerLibrary()->GetSampler(noise_sampler_desc);
  
   auto cube_map = CreateTextureCubeForFixture(
       {"table_mountain_px.png", "table_mountain_nx.png",
        "table_mountain_py.png", "table_mountain_ny.png",
        "table_mountain_pz.png", "table_mountain_nz.png"});
   raw_ptr<const Sampler> cube_map_sampler =
       context->GetSamplerLibrary()->GetSampler({});
   auto host_buffer = HostBuffer::Create(
       context->GetResourceAllocator(), context->GetIdleWaiter(),
       context->GetCapabilities()->GetMinimumUniformAlignment());
  
   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);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::SamplerDescriptor::height_address_mode, impeller::kCount4, impeller::kRepeat, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), and impeller::SamplerDescriptor::width_address_mode.

◆ TEST_P() [508/545]

impeller::testing::TEST_P	(	RendererTest	,
		VertexBufferBuilder
	)

Definition at line 1155 of file renderer_unittests.cc.

                                           {
   // Does not create index buffer if one is provided.
   using VS = BoxFadeVertexShader;
   VertexBufferBuilder<VS::PerVertexData> vertex_builder;
   vertex_builder.SetLabel("Box");
   vertex_builder.AddVertices({
       {{100, 100, 0.0}, {0.0, 0.0}},  // 1
       {{800, 100, 0.0}, {1.0, 0.0}},  // 2
       {{800, 800, 0.0}, {1.0, 1.0}},  // 3
       {{100, 800, 0.0}, {0.0, 1.0}},  // 4
   });
   vertex_builder.AppendIndex(0);
   vertex_builder.AppendIndex(1);
   vertex_builder.AppendIndex(2);
   vertex_builder.AppendIndex(1);
   vertex_builder.AppendIndex(2);
   vertex_builder.AppendIndex(3);
  
   ASSERT_EQ(vertex_builder.GetIndexCount(), 6u);
   ASSERT_EQ(vertex_builder.GetVertexCount(), 4u);
 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AppendIndex(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetIndexCount(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetVertexCount(), and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [509/545]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachedTextureGetsNewAttachmentConfig
	)

Definition at line 122 of file render_target_cache_unittests.cc.

                                                                     {
   auto render_target_cache = RenderTargetCache(
       GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/0);
  
   render_target_cache.Start();
   RenderTarget::AttachmentConfig color_attachment_config =
       RenderTarget::kDefaultColorAttachmentConfig;
   RenderTarget target1 = render_target_cache.CreateOffscreen(
       *GetContext(), {100, 100}, 1, "Offscreen1", color_attachment_config);
   render_target_cache.End();
  
   render_target_cache.Start();
   color_attachment_config.clear_color = Color::Red();
   RenderTarget target2 = render_target_cache.CreateOffscreen(
       *GetContext(), {100, 100}, 1, "Offscreen2", color_attachment_config);
   render_target_cache.End();
  
   ColorAttachment color1 = target1.GetColorAttachment(0);
   ColorAttachment color2 = target2.GetColorAttachment(0);
   // The second color attachment should reuse the first attachment's texture
   // but with attributes from the second AttachmentConfig.
   EXPECT_EQ(color2.texture, color1.texture);
   EXPECT_EQ(color2.clear_color, Color::Red());
 }

References impeller::ColorAttachment::clear_color, impeller::RenderTarget::AttachmentConfig::clear_color, impeller::RenderTarget::GetColorAttachment(), impeller::RenderTarget::kDefaultColorAttachmentConfig, impeller::Color::Red(), and impeller::Attachment::texture.

◆ TEST_P() [510/545]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachesUsedTexturesAcrossFrames
	)

Definition at line 52 of file render_target_cache_unittests.cc.

                                                               {
   auto render_target_cache = RenderTargetCache(
       GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/0);
  
   render_target_cache.Start();
   // Create two render targets of the same exact size/shape. Both should be
   // marked as used this frame, so the cached data set will contain two.
   render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
   render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
  
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
  
   render_target_cache.End();
   render_target_cache.Start();
  
   // Next frame, only create one texture. The set will still contain two,
   // but one will be removed at the end of the frame.
   render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
  
   render_target_cache.End();
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 1u);
 }

◆ TEST_P() [511/545]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachesUsedTexturesAcrossFramesWithKeepAlive
	)

Definition at line 76 of file render_target_cache_unittests.cc.

                                                                            {
   auto render_target_cache = RenderTargetCache(
       GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/3);
  
   render_target_cache.Start();
   // Create two render targets of the same exact size/shape. Both should be
   // marked as used this frame, so the cached data set will contain two.
   render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
   render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
  
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
  
   render_target_cache.End();
   render_target_cache.Start();
  
   // The unused texture is kept alive until the keep alive countdown
   // reaches 0.
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
  
   for (auto i = 0; i < 3; i++) {
     render_target_cache.Start();
     render_target_cache.End();
     EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
   }
   // After the countdown has elapsed the texture is removed.
   render_target_cache.Start();
   render_target_cache.End();
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 0u);
 }

◆ TEST_P() [512/545]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CreateWithEmptySize
	)

Definition at line 147 of file render_target_cache_unittests.cc.

                                                    {
   auto render_target_cache = RenderTargetCache(
       GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/0);
  
   render_target_cache.Start();
   RenderTarget empty_target =
       render_target_cache.CreateOffscreen(*GetContext(), {100, 0}, 1);
   RenderTarget empty_target_msaa =
       render_target_cache.CreateOffscreenMSAA(*GetContext(), {0, 0}, 1);
   render_target_cache.End();
  
   {
     ScopedValidationDisable disable_validation;
     EXPECT_FALSE(empty_target.IsValid());
     EXPECT_FALSE(empty_target_msaa.IsValid());
   }
 }

References impeller::RenderTarget::IsValid().

◆ TEST_P() [513/545]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		DoesNotPersistFailedAllocations
	)

Definition at line 106 of file render_target_cache_unittests.cc.

                                                                {
   ScopedValidationDisable disable;
   auto allocator = std::make_shared<TestAllocator>();
   auto render_target_cache =
       RenderTargetCache(allocator, /*keep_alive_frame_count=*/0);
  
   render_target_cache.Start();
   allocator->should_fail = true;
  
   auto render_target =
       render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
  
   EXPECT_FALSE(render_target.IsValid());
   EXPECT_EQ(render_target_cache.CachedTextureCount(), 0u);
 }

◆ TEST_P() [514/545]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanCreatePipelineFromRuntimeStage
	)

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

References impeller::PipelineDescriptor::AddStageEntrypoint(), impeller::DescriptorSetLayout::binding, impeller::ColorAttachmentDescriptor::format, impeller::kEqual, impeller::kFragment, impeller::kUniformBuffer, impeller::kVertex, impeller::PlaygroundBackendToRuntimeStageBackend(), impeller::PipelineDescriptor::SetColorAttachmentDescriptor(), impeller::PipelineDescriptor::SetLabel(), impeller::PipelineDescriptor::SetStencilAttachmentDescriptors(), impeller::PipelineDescriptor::SetStencilPixelFormat(), impeller::PipelineDescriptor::SetVertexDescriptor(), and impeller::StencilAttachmentDescriptor::stencil_compare.

◆ TEST_P() [515/545]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniforms
	)

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

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kFloat, impeller::kMetal, impeller::kOpenGLES, impeller::kStruct, impeller::kVulkan, impeller::RuntimeStage::kVulkanUBOName, and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [516/545]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniformsSamplerAfterUBO
	)

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

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kSampledImage, impeller::kStruct, impeller::kVulkan, impeller::RuntimeStage::kVulkanUBOName, and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [517/545]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniformsSamplerBeforeUBO
	)

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

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kSampledImage, impeller::kStruct, impeller::kVulkan, impeller::RuntimeStage::kVulkanUBOName, and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [518/545]

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

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kFragment, and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [519/545]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanRegisterStage
	)

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

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kFragment, impeller::PlaygroundBackendToRuntimeStageBackend(), and impeller::ToShaderStage().

◆ TEST_P() [520/545]

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(Bytes{fixture->GetSize()}, false));
   // Not meant to be secure. Just reject obviously bad blobs using magic
   // numbers.
   ::memset(junk_allocation->GetBuffer(), 127,
            junk_allocation->GetLength().GetByteSize());
   auto stages = RuntimeStage::DecodeRuntimeStages(
       CreateMappingFromAllocation(junk_allocation));
   ASSERT_FALSE(stages[PlaygroundBackendToRuntimeStageBackend(GetBackend())]);
 }

References impeller::CreateMappingFromAllocation(), impeller::RuntimeStage::DecodeRuntimeStages(), and impeller::PlaygroundBackendToRuntimeStageBackend().

◆ TEST_P() [521/545]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		ContainsExpectedShaderTypes
	)

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

References impeller::kMetal, impeller::kOpenGLES, impeller::kSkSL, and impeller::kVulkan.

◆ TEST_P() [522/545]

impeller::testing::TEST_P	(	SwapchainTransientsMTLTest	,
		CanAllocateSwapchainTextures
	)

Definition at line 27 of file swapchain_transients_mtl_unittests.mm.

                                                                  {
   const auto& transients = std::make_shared<SwapchainTransientsMTL>(
       GetContext()->GetResourceAllocator());
  
   transients->SetSizeAndFormat({1, 1}, PixelFormat::kB8G8R8A8UNormInt);
  
   auto resolve = transients->GetResolveTexture();
   EXPECT_NE(resolve, nullptr);
   EXPECT_NE(transients->GetMSAATexture(), nullptr);
   EXPECT_NE(transients->GetDepthStencilTexture(), nullptr);
  
   // Texture properties are correct for resolve.
   EXPECT_EQ(resolve->GetTextureDescriptor().size, ISize(1, 1));
   EXPECT_EQ(resolve->GetTextureDescriptor().format,
             PixelFormat::kB8G8R8A8UNormInt);
   EXPECT_EQ(resolve->GetTextureDescriptor().sample_count, SampleCount::kCount1);
   EXPECT_EQ(resolve->GetTextureDescriptor().storage_mode,
             StorageMode::kDevicePrivate);
  
   // Texture properties are correct for MSAA.
   auto msaa = transients->GetMSAATexture();
   EXPECT_EQ(msaa->GetTextureDescriptor().size, ISize(1, 1));
   EXPECT_EQ(msaa->GetTextureDescriptor().format,
             PixelFormat::kB8G8R8A8UNormInt);
   EXPECT_EQ(msaa->GetTextureDescriptor().sample_count, SampleCount::kCount4);
   EXPECT_EQ(msaa->GetTextureDescriptor().storage_mode,
             StorageMode::kDeviceTransient);
  
   // Texture properties are correct for Depth+Stencil.
   auto depth_stencil = transients->GetDepthStencilTexture();
   EXPECT_EQ(depth_stencil->GetTextureDescriptor().size, ISize(1, 1));
   EXPECT_EQ(depth_stencil->GetTextureDescriptor().format,
             PixelFormat::kD32FloatS8UInt);
   EXPECT_EQ(depth_stencil->GetTextureDescriptor().sample_count,
             SampleCount::kCount4);
   EXPECT_EQ(depth_stencil->GetTextureDescriptor().storage_mode,
             StorageMode::kDeviceTransient);
  
   // Textures are cached.
   EXPECT_EQ(transients->GetResolveTexture(), resolve);
  
   // Texture cache is invalidated when size changes.
   transients->SetSizeAndFormat({2, 2}, PixelFormat::kB8G8R8A8UNormInt);
   EXPECT_NE(resolve, transients->GetResolveTexture());
   resolve = transients->GetResolveTexture();
  
   // Texture cache is invalidated when pixel format changes.
   transients->SetSizeAndFormat({2, 2}, PixelFormat::kB10G10R10A10XR);
   EXPECT_NE(resolve, transients->GetResolveTexture());
 }

References impeller::kB10G10R10A10XR, impeller::kB8G8R8A8UNormInt, impeller::kCount1, impeller::kCount4, impeller::kD32FloatS8UInt, impeller::kDevicePrivate, and impeller::kDeviceTransient.

◆ TEST_P() [523/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		MaintainsShape
	)

Definition at line 184 of file text_contents_unittests.cc.

                                          {
   std::shared_ptr<TextFrame> text_frame =
       MakeTextFrame("th", "ahem.ttf", TextOptions{.font_size = 50});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
  
   for (int i = 0; i <= 1000; ++i) {
     Rational font_scale(440 + i, 1000.0);
     Rect position_rect[2];
     Rect uv_rect[2];
  
     {
       std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(12);
  
       std::shared_ptr<GlyphAtlas> atlas =
           CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                            GlyphAtlas::Type::kAlphaBitmap, font_scale,
                            atlas_context, text_frame, /*offset=*/{0, 0});
       ISize texture_size = atlas->GetTexture()->GetSize();
  
       TextContents::ComputeVertexData(
           data.data(), text_frame, static_cast<Scalar>(font_scale),
           /*entity_transform=*/
           Matrix::MakeScale({static_cast<Scalar>(font_scale),
                              static_cast<Scalar>(font_scale), 1}),
           /*offset=*/Vector2(0, 0),
           /*glyph_properties=*/std::nullopt, atlas);
       position_rect[0] = PerVertexDataPositionToRect(data.begin());
       uv_rect[0] = PerVertexDataUVToRect(data.begin(), texture_size);
       position_rect[1] = PerVertexDataPositionToRect(data.begin() + 4);
       uv_rect[1] = PerVertexDataUVToRect(data.begin() + 4, texture_size);
     }
     EXPECT_NEAR(GetAspectRatio(position_rect[1]), GetAspectRatio(uv_rect[1]),
                 0.001)
         << i;
   }
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::Matrix::MakeScale().

◆ TEST_P() [524/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleComputeVertexData
	)

Definition at line 110 of file text_contents_unittests.cc.

                                                   {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Results aren't stable across linux and macos.";
 #endif
  
   std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
  
   std::shared_ptr<TextFrame> text_frame =
       MakeTextFrame("1", "ahem.ttf", TextOptions{.font_size = 50});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   std::shared_ptr<GlyphAtlas> atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, /*scale=*/Rational(1, 1),
                        atlas_context, text_frame, /*offset=*/{0, 0});
  
   ISize texture_size = atlas->GetTexture()->GetSize();
   TextContents::ComputeVertexData(data.data(), text_frame, /*scale=*/1.0,
                                   /*entity_transform=*/Matrix(),
                                   /*offset=*/Vector2(0, 0),
                                   /*glyph_properties=*/std::nullopt, atlas);
  
   Rect position_rect = PerVertexDataPositionToRect(data.begin());
   Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
   // The -1 offset comes from Skia in `ComputeGlyphSize`. So since the font size
   // is 50, the math appears to be to get back a 50x50 rect and apply 1 pixel
   // of padding.
   EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
   EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [525/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleComputeVertexData2x
	)

Definition at line 147 of file text_contents_unittests.cc.

                                                     {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Results aren't stable across linux and macos.";
 #endif
  
   std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
   std::shared_ptr<TextFrame> text_frame =
       MakeTextFrame("1", "ahem.ttf", TextOptions{.font_size = 50});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   Rational font_scale(2, 1);
   std::shared_ptr<GlyphAtlas> atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, font_scale,
                        atlas_context, text_frame, /*offset=*/{0, 0});
  
   ISize texture_size = atlas->GetTexture()->GetSize();
   TextContents::ComputeVertexData(
       data.data(), text_frame, static_cast<Scalar>(font_scale),
       /*entity_transform=*/
       Matrix::MakeScale({static_cast<Scalar>(font_scale),
                          static_cast<Scalar>(font_scale), 1}),
       /*offset=*/Vector2(0, 0),
       /*glyph_properties=*/std::nullopt, atlas);
  
   Rect position_rect = PerVertexDataPositionToRect(data.begin());
   Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
   EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -81, 102, 102));
   EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 102, 102));
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [526/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel
	)

Definition at line 228 of file text_contents_unittests.cc.

                                          {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Results aren't stable across linux and macos.";
 #endif
  
   std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
  
   std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
       "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   Point offset = Point(0.5, 0);
   std::shared_ptr<GlyphAtlas> atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, /*scale=*/Rational(1),
                        atlas_context, text_frame, offset);
  
   ISize texture_size = atlas->GetTexture()->GetSize();
   TextContents::ComputeVertexData(
       data.data(), text_frame, /*scale=*/1.0,
       /*entity_transform=*/Matrix::MakeTranslation(offset), offset,
       /*glyph_properties=*/std::nullopt, atlas);
  
   Rect position_rect = PerVertexDataPositionToRect(data.begin());
   Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
   // The values at Point(0, 0).
   // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
   // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
   EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -41, 54, 52));
   EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 54, 52));
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeTranslation(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [527/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel26
	)

Definition at line 311 of file text_contents_unittests.cc.

                                            {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Results aren't stable across linux and macos.";
 #endif
  
   std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
  
   std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
       "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   Point offset = Point(0.26, 0);
   std::shared_ptr<GlyphAtlas> atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, /*scale=*/Rational(1),
                        atlas_context, text_frame, offset);
  
   ISize texture_size = atlas->GetTexture()->GetSize();
   TextContents::ComputeVertexData(
       data.data(), text_frame, /*scale=*/1.0,
       /*entity_transform=*/Matrix::MakeTranslation(offset), offset,
       /*glyph_properties=*/std::nullopt, atlas);
  
   Rect position_rect = PerVertexDataPositionToRect(data.begin());
   Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
   // The values without subpixel.
   // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
   // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
   EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -41, 54, 52));
   EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 54, 52));
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeTranslation(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [528/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel3x
	)

Definition at line 266 of file text_contents_unittests.cc.

                                            {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Results aren't stable across linux and macos.";
 #endif
  
   std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
  
   std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
       "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   Rational font_scale(3, 1);
   Point offset = {0.16667, 0};
   std::shared_ptr<GlyphAtlas> atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, font_scale,
                        atlas_context, text_frame, offset);
  
   ISize texture_size = atlas->GetTexture()->GetSize();
   TextContents::ComputeVertexData(
       data.data(), text_frame, static_cast<Scalar>(font_scale),
       /*entity_transform=*/
       Matrix::MakeTranslation(offset) *
           Matrix::MakeScale({static_cast<Scalar>(font_scale),
                              static_cast<Scalar>(font_scale), 1}),
       offset,
       /*glyph_properties=*/std::nullopt, atlas);
  
   Rect position_rect = PerVertexDataPositionToRect(data.begin());
   Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
   // Values at Point(0, 0)
   // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -121, 152, 152));
   // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 152, 152));
   EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -121, 154, 152))
       << "position size:" << position_rect.GetSize();
   EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 154, 152))
       << "position size:" << position_rect.GetSize();
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, EXPECT_RECT_NEAR, impeller::TRect< T >::GetSize(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [529/545]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel80
	)

Definition at line 349 of file text_contents_unittests.cc.

                                            {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Results aren't stable across linux and macos.";
 #endif
  
   std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
  
   std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
       "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
  
   std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
   std::shared_ptr<GlyphAtlasContext> atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   std::shared_ptr<HostBuffer> host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   Point offset = Point(0.80, 0);
   std::shared_ptr<GlyphAtlas> atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, /*scale=*/Rational(1),
                        atlas_context, text_frame, offset);
  
   ISize texture_size = atlas->GetTexture()->GetSize();
   TextContents::ComputeVertexData(
       data.data(), text_frame, /*scale=*/1.0,
       /*entity_transform=*/Matrix::MakeTranslation(offset), offset,
       /*glyph_properties=*/std::nullopt, atlas);
  
   Rect position_rect = PerVertexDataPositionToRect(data.begin());
   Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
   // The values without subpixel.
   // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
   // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
   EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -41, 54, 52));
   EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 54, 52));
 }

References impeller::TextContents::ComputeVertexData(), impeller::HostBuffer::Create(), CreateGlyphAtlas(), data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeTranslation(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [530/545]

impeller::testing::TEST_P	(	TypographerTest	,
		CanConvertTextBlob
	)

Definition at line 62 of file typographer_unittests.cc.

                                             {
   SkFont font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString(
       "the quick brown fox jumped over the lazy dog.", font);
   ASSERT_TRUE(blob);
   auto frame = MakeTextFrameFromTextBlobSkia(blob);
   ASSERT_EQ(frame->GetRunCount(), 1u);
   for (const auto& run : frame->GetRuns()) {
     ASSERT_TRUE(run.IsValid());
     ASSERT_EQ(run.GetGlyphCount(), 45u);
   }
 }

References impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [531/545]

impeller::testing::TEST_P	(	TypographerTest	,
		CanCreateGlyphAtlas
	)

Definition at line 80 of file typographer_unittests.cc.

                                              {
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString("hello", sk_font);
   ASSERT_TRUE(blob);
   auto atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, Rational(1),
                        atlas_context, MakeTextFrameFromTextBlobSkia(blob));
  
   ASSERT_NE(atlas, nullptr);
   ASSERT_NE(atlas->GetTexture(), nullptr);
   ASSERT_EQ(atlas->GetType(), GlyphAtlas::Type::kAlphaBitmap);
   ASSERT_EQ(atlas->GetGlyphCount(), 4llu);
  
   std::optional<impeller::ScaledFont> first_scaled_font;
   std::optional<impeller::SubpixelGlyph> first_glyph;
   Rect first_rect;
   atlas->IterateGlyphs([&](const ScaledFont& scaled_font,
                            const SubpixelGlyph& glyph,
                            const Rect& rect) -> bool {
     first_scaled_font = scaled_font;
     first_glyph = glyph;
     first_rect = rect;
     return false;
   });
  
   ASSERT_TRUE(first_scaled_font.has_value());
   ASSERT_TRUE(atlas
                   ->FindFontGlyphBounds(
                       {first_scaled_font.value(), first_glyph.value()})
                   .has_value());
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [532/545]

impeller::testing::TEST_P	(	TypographerTest	,
		CanCreateRenderContext
	)

Definition at line 75 of file typographer_unittests.cc.

                                                 {
   auto context = TypographerContextSkia::Make();
   ASSERT_TRUE(context && context->IsValid());
 }

References impeller::TypographerContextSkia::Make().

◆ TEST_P() [533/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasIsRecycledIfUnchanged
	)

Definition at line 183 of file typographer_unittests.cc.

                                                          {
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString("spooky skellingtons", sk_font);
   ASSERT_TRUE(blob);
   auto atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, Rational(1),
                        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, Rational(1),
                        atlas_context, MakeTextFrameFromTextBlobSkia(blob));
   ASSERT_EQ(atlas, next_atlas);
   ASSERT_EQ(atlas_context->GetGlyphAtlas(), atlas);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [534/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasTextureIsRecycledIfUnchanged
	)

Definition at line 262 of file typographer_unittests.cc.

                                                                 {
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   ASSERT_TRUE(context && context->IsValid());
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString("spooky 1", sk_font);
   ASSERT_TRUE(blob);
   auto atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, Rational(1),
                        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, Rational(1),
                        atlas_context, MakeTextFrameFromTextBlobSkia(blob2));
   ASSERT_EQ(atlas, next_atlas);
   auto* second_texture = next_atlas->GetTexture().get();
  
   auto new_packer = atlas_context->GetRectPacker();
  
   ASSERT_EQ(second_texture, first_texture);
   ASSERT_EQ(old_packer, new_packer);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [535/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasTextureWillGrowTilMaxTextureSize
	)

Definition at line 434 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(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   ASSERT_TRUE(context && context->IsValid());
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString("A", sk_font);
   ASSERT_TRUE(blob);
   auto atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, Rational(1),
                        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!
   };
  
   SkFont sk_font_small = flutter::testing::CreateTestFontOfSize(10);
  
   for (int i = 0; i < 13; i++) {
     SkTextBlobBuilder builder;
  
     auto add_char = [&](const SkFont& sk_font, char c) {
       int count = sk_font.countText(&c, 1, SkTextEncoding::kUTF8);
       auto buffer = builder.allocRunPos(sk_font, count);
       sk_font.textToGlyphs(&c, 1, SkTextEncoding::kUTF8, buffer.glyphs, count);
       sk_font.getPos(buffer.glyphs, count, buffer.points(), {0, 0});
     };
  
     SkFont sk_font = flutter::testing::CreateTestFontOfSize(50 + i);
     add_char(sk_font, 'A');
     add_char(sk_font_small, 'B');
     auto blob = builder.make();
  
     atlas =
         CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                          GlyphAtlas::Type::kAlphaBitmap, Rational(50 + i, 1),
                          atlas_context, MakeTextFrameFromTextBlobSkia(blob));
     ASSERT_TRUE(!!atlas);
     EXPECT_EQ(atlas->GetTexture()->GetTextureDescriptor().size,
               expected_sizes[i]);
   }
  
   // The final atlas should contain both the "A" glyph (which was not present
   // in the previous atlas) and the "B" glyph (which existed in the previous
   // atlas).
   ASSERT_EQ(atlas->GetGlyphCount(), 2u);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::kOpenGLES, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [536/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasWithLotsOfdUniqueGlyphSize
	)

Definition at line 212 of file typographer_unittests.cc.

                                                               {
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   ASSERT_TRUE(context && context->IsValid());
  
   const char* test_string =
       "QWERTYUIOPASDFGHJKLZXCVBNMqewrtyuiopasdfghjklzxcvbnm,.<>[]{};':"
       "2134567890-=!@#$%^&*()_+"
       "œ∑´®†¥¨ˆøπ““‘‘åß∂ƒ©˙∆˚¬…æ≈ç√∫˜µ≤≥≥≥≥÷¡™£¢∞§¶•ªº–≠⁄€‹›ﬁﬂ‡°·‚—±Œ„´‰Á¨Ø∏”’/"
       "* Í˝ */¸˛Ç◊ı˜Â¯˘¿";
  
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString(test_string, sk_font);
   ASSERT_TRUE(blob);
  
   size_t size_count = 8;
   std::vector<std::shared_ptr<TextFrame>> frames;
   for (size_t index = 0; index < size_count; index += 1) {
     frames.push_back(MakeTextFrameFromTextBlobSkia(blob));
     frames.back()->SetPerFrameData(Rational(6 * index, 10), {0, 0}, Matrix(),
                                    {});
   };
   auto atlas =
       context->CreateGlyphAtlas(*GetContext(), GlyphAtlas::Type::kAlphaBitmap,
                                 *host_buffer, atlas_context, frames);
   ASSERT_NE(atlas, nullptr);
   ASSERT_NE(atlas->GetTexture(), nullptr);
  
   std::set<uint16_t> unique_glyphs;
   std::vector<uint16_t> total_glyphs;
   atlas->IterateGlyphs([&](const ScaledFont& scaled_font,
                            const SubpixelGlyph& glyph, const Rect& rect) {
     unique_glyphs.insert(glyph.glyph.index);
     total_glyphs.push_back(glyph.glyph.index);
     return true;
   });
  
   // These numbers may be different due to subpixel positions.
   EXPECT_LE(unique_glyphs.size() * size_count, atlas->GetGlyphCount());
   EXPECT_EQ(total_glyphs.size(), atlas->GetGlyphCount());
  
   EXPECT_TRUE(atlas->GetGlyphCount() > 0);
   EXPECT_TRUE(atlas->GetTexture()->GetSize().width > 0);
   EXPECT_TRUE(atlas->GetTexture()->GetSize().height > 0);
 }

References impeller::HostBuffer::Create(), impeller::SubpixelGlyph::glyph, impeller::Glyph::index, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [537/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasWithOddUniqueGlyphSize
	)

Definition at line 161 of file typographer_unittests.cc.

                                                           {
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   ASSERT_TRUE(context && context->IsValid());
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
   auto blob = SkTextBlob::MakeFromString("AGH", sk_font);
   ASSERT_TRUE(blob);
   auto atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kAlphaBitmap, Rational(1),
                        atlas_context, MakeTextFrameFromTextBlobSkia(blob));
   ASSERT_NE(atlas, nullptr);
   ASSERT_NE(atlas->GetTexture(), nullptr);
  
   EXPECT_EQ(atlas->GetTexture()->GetSize().width, 4096u);
   EXPECT_EQ(atlas->GetTexture()->GetSize().height, 1024u);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [538/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphColorIsIgnoredForNonEmojiFonts
	)

Definition at line 337 of file typographer_unittests.cc.

                                                              {
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   sk_sp<SkTypeface> typeface =
       font_mgr->matchFamilyStyle("Arial", SkFontStyle::Normal());
   SkFont sk_font(typeface, 0.5f);
  
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kColorBitmap);
  
   // Create two frames with the same character and a different color, but as a
   // non-emoji font the text frame constructor will ignore it.
   auto frame =
       MakeTextFrameFromTextBlobSkia(SkTextBlob::MakeFromString("A", sk_font));
   auto frame_2 =
       MakeTextFrameFromTextBlobSkia(SkTextBlob::MakeFromString("A", sk_font));
   std::vector<std::optional<GlyphProperties>> properties = {
       GlyphProperties{},
       GlyphProperties{},
   };
  
   auto next_atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kColorBitmap, Rational(1),
                        atlas_context, {frame, frame_2}, properties);
  
   EXPECT_EQ(next_atlas->GetGlyphCount(), 1u);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [539/545]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphColorIsPartOfCacheKey
	)

Definition at line 301 of file typographer_unittests.cc.

                                                     {
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
 #if FML_OS_MACOSX
   auto mapping = flutter::testing::OpenFixtureAsSkData("Apple Color Emoji.ttc");
 #else
   auto mapping = flutter::testing::OpenFixtureAsSkData("NotoColorEmoji.ttf");
 #endif
   ASSERT_TRUE(mapping);
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   SkFont emoji_font(font_mgr->makeFromData(mapping), 50.0);
  
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kColorBitmap);
  
   // Create two frames with the same character and a different color, expect
   // that it adds a character.
   auto frame = MakeTextFrameFromTextBlobSkia(
       SkTextBlob::MakeFromString("😂", emoji_font));
   auto frame_2 = MakeTextFrameFromTextBlobSkia(
       SkTextBlob::MakeFromString("😂", emoji_font));
   std::vector<std::optional<GlyphProperties>> properties = {
       GlyphProperties{.color = Color::Red()},
       GlyphProperties{.color = Color::Blue()},
   };
  
   auto next_atlas =
       CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                        GlyphAtlas::Type::kColorBitmap, Rational(1),
                        atlas_context, {frame, frame_2}, properties);
  
   EXPECT_EQ(next_atlas->GetGlyphCount(), 2u);
 }

References impeller::Color::Blue(), impeller::GlyphProperties::color, impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), impeller::MakeTextFrameFromTextBlobSkia(), and impeller::Color::Red().

◆ TEST_P() [540/545]

impeller::testing::TEST_P	(	TypographerTest	,
		InvalidAtlasForcesRepopulation
	)

Definition at line 628 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);
  
   EXPECT_FALSE(frame->IsFrameComplete());
  
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  
   auto atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                                 GlyphAtlas::Type::kAlphaBitmap,
                                 /*scale=*/Rational(1), atlas_context, frame);
  
   // The glyph position in the atlas was not known when this value
   // was recorded. It is marked as a placeholder.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_TRUE(frame->GetFrameBounds(0).is_placeholder);
   if (GetBackend() == PlaygroundBackend::kOpenGLES) {
     // OpenGLES must always increase the atlas backend if the texture grows.
     EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 1u);
   } else {
     EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 0u);
   }
  
   auto second_context = TypographerContextSkia::Make();
   auto second_atlas_context =
       second_context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  
   EXPECT_FALSE(second_atlas_context->GetGlyphAtlas()->IsValid());
  
   atlas = CreateGlyphAtlas(*GetContext(), second_context.get(), *host_buffer,
                            GlyphAtlas::Type::kAlphaBitmap,
                            /*scale=*/Rational(1), second_atlas_context, frame);
  
   EXPECT_TRUE(second_atlas_context->GetGlyphAtlas()->IsValid());
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::kOpenGLES, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [541/545]

impeller::testing::TEST_P	(	TypographerTest	,
		LazyAtlasTracksColor
	)

Definition at line 120 of file typographer_unittests.cc.

                                               {
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
 #if FML_OS_MACOSX
   auto mapping = flutter::testing::OpenFixtureAsSkData("Apple Color Emoji.ttc");
 #else
   auto mapping = flutter::testing::OpenFixtureAsSkData("NotoColorEmoji.ttf");
 #endif
   ASSERT_TRUE(mapping);
   sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
   SkFont emoji_font(font_mgr->makeFromData(mapping), 50.0);
   SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  
   auto blob = SkTextBlob::MakeFromString("hello", sk_font);
   ASSERT_TRUE(blob);
   auto frame = MakeTextFrameFromTextBlobSkia(blob);
  
   ASSERT_FALSE(frame->GetAtlasType() == GlyphAtlas::Type::kColorBitmap);
  
   LazyGlyphAtlas lazy_atlas(TypographerContextSkia::Make());
  
   lazy_atlas.AddTextFrame(frame, Rational(1), {0, 0}, Matrix(), {});
  
   frame = MakeTextFrameFromTextBlobSkia(
       SkTextBlob::MakeFromString("😀 ", emoji_font));
  
   ASSERT_TRUE(frame->GetAtlasType() == GlyphAtlas::Type::kColorBitmap);
  
   lazy_atlas.AddTextFrame(frame, Rational(1), {0, 0}, Matrix(), {});
  
   // 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);
 }

References impeller::LazyGlyphAtlas::AddTextFrame(), impeller::HostBuffer::Create(), impeller::LazyGlyphAtlas::CreateOrGetGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [542/545]

impeller::testing::TEST_P	(	TypographerTest	,
		RectanglePackerAddsNonoverlapingRectangles
	)

Definition at line 369 of file typographer_unittests.cc.

                                                                     {
   auto packer = RectanglePacker::Factory(200, 100);
   ASSERT_NE(packer, nullptr);
   ASSERT_EQ(packer->PercentFull(), 0);
  
   const SkIRect packer_area = SkIRect::MakeXYWH(0, 0, 200, 100);
  
   IPoint16 first_output = {-1, -1};  // Fill with sentinel values
   ASSERT_TRUE(packer->AddRect(20, 20, &first_output));
   // Make sure the rectangle is placed such that it is inside the bounds of
   // the packer's area.
   const SkIRect first_rect =
       SkIRect::MakeXYWH(first_output.x(), first_output.y(), 20, 20);
   ASSERT_TRUE(SkIRect::Intersects(packer_area, first_rect));
  
   // Initial area was 200 x 100 = 20_000
   // We added 20x20 = 400. 400 / 20_000 == 0.02 == 2%
   ASSERT_TRUE(flutter::testing::NumberNear(packer->PercentFull(), 0.02));
  
   IPoint16 second_output = {-1, -1};
   ASSERT_TRUE(packer->AddRect(140, 90, &second_output));
   const SkIRect second_rect =
       SkIRect::MakeXYWH(second_output.x(), second_output.y(), 140, 90);
   // Make sure the rectangle is placed such that it is inside the bounds of
   // the packer's area but not in the are of the first rectangle.
   ASSERT_TRUE(SkIRect::Intersects(packer_area, second_rect));
   ASSERT_FALSE(SkIRect::Intersects(first_rect, second_rect));
  
   // We added another 90 x 140 = 12_600 units, now taking us to 13_000
   // 13_000 / 20_000 == 0.65 == 65%
   ASSERT_TRUE(flutter::testing::NumberNear(packer->PercentFull(), 0.65));
  
   // There's enough area to add this rectangle, but no space big enough for
   // the 50 units of width.
   IPoint16 output;
   ASSERT_FALSE(packer->AddRect(50, 50, &output));
   // Should be unchanged.
   ASSERT_TRUE(flutter::testing::NumberNear(packer->PercentFull(), 0.65));
  
   packer->Reset();
   // Should be empty now.
   ASSERT_EQ(packer->PercentFull(), 0);
 }

References impeller::RectanglePacker::Factory(), NumberNear(), impeller::IPoint16::x(), and impeller::IPoint16::y().

◆ TEST_P() [543/545]

impeller::testing::TEST_P	(	TypographerTest	,
		TextFrameAtlasGenerationTracksState
	)

Definition at line 575 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);
  
   EXPECT_FALSE(frame->IsFrameComplete());
  
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  
   auto atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                                 GlyphAtlas::Type::kAlphaBitmap,
                                 /*scale=*/Rational(1), atlas_context, frame);
  
   // The glyph position in the atlas was not known when this value
   // was recorded. It is marked as a placeholder.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_TRUE(frame->GetFrameBounds(0).is_placeholder);
   if (GetBackend() == PlaygroundBackend::kOpenGLES) {
     // OpenGLES must always increase the atlas backend if the texture grows.
     EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 1u);
   } else {
     EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 0u);
   }
  
   atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                            GlyphAtlas::Type::kAlphaBitmap,
                            /*scale=*/Rational(1), atlas_context, frame);
  
   // The second time the glyph is rendered, the bounds are correcly known.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_FALSE(frame->GetFrameBounds(0).is_placeholder);
   if (GetBackend() == PlaygroundBackend::kOpenGLES) {
     EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 1u);
   } else {
     EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 0u);
   }
  
   // Force increase the generation.
   atlas_context->GetGlyphAtlas()->SetAtlasGeneration(2u);
   atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                            GlyphAtlas::Type::kAlphaBitmap,
                            /*scale=*/Rational(1), atlas_context, frame);
  
   EXPECT_EQ(frame->GetAtlasGenerationAndID().first, 2u);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::kOpenGLES, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [544/545]

impeller::testing::TEST_P	(	TypographerTest	,
		TextFrameInitialBoundsArePlaceholder
	)

Definition at line 505 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);
  
   EXPECT_FALSE(frame->IsFrameComplete());
  
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  
   auto atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                                 GlyphAtlas::Type::kAlphaBitmap,
                                 /*scale=*/Rational(1), atlas_context, frame);
  
   // The glyph position in the atlas was not known when this value
   // was recorded. It is marked as a placeholder.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_TRUE(frame->GetFrameBounds(0).is_placeholder);
  
   atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                            GlyphAtlas::Type::kAlphaBitmap,
                            /*scale=*/Rational(1), atlas_context, frame);
  
   // The second time the glyph is rendered, the bounds are correcly known.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_FALSE(frame->GetFrameBounds(0).is_placeholder);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [545/545]

impeller::testing::TEST_P	(	TypographerTest	,
		TextFrameInvalidationWithScale
	)

Definition at line 539 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);
  
   EXPECT_FALSE(frame->IsFrameComplete());
  
   auto context = TypographerContextSkia::Make();
   auto atlas_context =
       context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
   auto host_buffer = HostBuffer::Create(
       GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
       GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  
   auto atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                                 GlyphAtlas::Type::kAlphaBitmap,
                                 /*scale=*/Rational(1), atlas_context, frame);
  
   // The glyph position in the atlas was not known when this value
   // was recorded. It is marked as a placeholder.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_TRUE(frame->GetFrameBounds(0).is_placeholder);
  
   // Change the scale and the glyph data will still be a placeholder, as the
   // old data is no longer valid.
   atlas = CreateGlyphAtlas(*GetContext(), context.get(), *host_buffer,
                            GlyphAtlas::Type::kAlphaBitmap,
                            /*scale=*/Rational(2), atlas_context, frame);
  
   // The second time the glyph is rendered, the bounds are correcly known.
   EXPECT_TRUE(frame->IsFrameComplete());
   EXPECT_TRUE(frame->GetFrameBounds(0).is_placeholder);
 }

References impeller::HostBuffer::Create(), CreateGlyphAtlas(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ toColor()

flutter::DlColor impeller::testing::toColor ( const float * components )

Definition at line 38 of file dl_unittests.cc.

                                                 {
   return flutter::DlColor(Color::ToIColor(
       Color(components[0], components[1], components[2], components[3])));
 }

References impeller::Color::ToIColor().

Referenced by TEST_P().

Variable Documentation

◆ golden_cubic_and_quad_points

std::vector<Point> impeller::testing::golden_cubic_and_quad_points

Definition at line 15 of file golden_paths.h.

◆ kFontFixture

constexpr std::string_view impeller::testing::kFontFixture

staticconstexpr

Initial value:

=
 
    "NotoColorEmoji.ttf"

Definition at line 375 of file aiks_dl_text_unittests.cc.

Referenced by TEST_P().

◆ kMagicFailingAllocation

constexpr const size_t impeller::testing::kMagicFailingAllocation = 1024000 * 2

staticconstexpr

Definition at line 191 of file host_buffer_unittests.cc.

Referenced by impeller::testing::FailingAllocator::OnCreateBuffer(), and TEST_P().

◆ kPaintVariations

const std::map<std::string, MaskBlurTestConfig> impeller::testing::kPaintVariations

static

Definition at line 586 of file aiks_dl_blur_unittests.cc.

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AiksTest

◆ AllocatorMTLTest

◆ BlitPassTest

◆ ComputeTest

◆ ContextMTLTest

◆ DeviceBufferTest

◆ DisplayListTest

◆ DlPathReceiverMock

◆ DriverInfoVKTest

◆ EntityPassTargetTest

◆ EntityTest

◆ HostBufferTest

◆ PipelineCacheDataVKPlaygroundTest

◆ RendererTest

◆ RenderTargetCacheTest

◆ RuntimeStageTest

◆ SaveLayerUtilsTest

◆ SwapchainTransientsMTLTest

◆ TextContentsTest

◆ TypographerTest

Function Documentation

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [1/4]

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [2/4]

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [3/4]

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [4/4]

◆ BlendModeTest()

◆ CanBatchSubmitTest()

◆ CanRenderConicalGradientWithDithering()

◆ CanRenderLinearGradientWithDithering()

◆ CanRenderRadialGradientWithDithering()

◆ CanRenderSweepGradientWithDithering()

◆ CanUseFramebufferFetch()

◆ CanUseMipgeneration()

◆ CanUsePrimitiveRestartSubmitTest()

◆ CAPABILITY_TEST() [1/11]

◆ CAPABILITY_TEST() [2/11]

◆ CAPABILITY_TEST() [3/11]

◆ CAPABILITY_TEST() [4/11]

◆ CAPABILITY_TEST() [5/11]

◆ CAPABILITY_TEST() [6/11]

◆ CAPABILITY_TEST() [7/11]

◆ CAPABILITY_TEST() [8/11]

◆ CAPABILITY_TEST() [9/11]

◆ CAPABILITY_TEST() [10/11]

◆ CAPABILITY_TEST() [11/11]

◆ CompareFunctionUI()

◆ CreateDefaultPipeline()

◆ CreateGlyphAtlas() [1/2]

◆ CreateGlyphAtlas() [2/2]

◆ CreateMappingFromString()

◆ CreateStringFromMapping()

◆ CreateTestCanvas()

◆ CreateTestYUVTextures()

◆ DoGradientOvalStrokeMaskBlur()

◆ flip_lr()

◆ flip_lrtb()

◆ flip_tb()

◆ FML_TEST_CLASS() [1/2]

◆ FML_TEST_CLASS() [2/2]

◆ GetBlendModeSelection()

◆ INSTANTIATE_COMPUTE_SUITE()

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

◆ IsBadVersionTest()

◆ MaskBlurVariantTest()