Flutter Windows Embedder
Classes | Functions | Variables
flutter::testing Namespace Reference

Classes

class  AccessibilityPluginTest
 
class  CursorHandlerTest
 
class  MockIDirectManipulationViewport
 
class  MockIDirectManipulationContent
 
class  DisplayManagerWin32Test
 
class  FlutterWindowsEngineTest
 
class  MockFlutterWindowsView
 
class  MockWindowsLifecycleManager
 
class  PlatformHandlerTest
 
class  TestTaskRunnerWindow
 
class  TextInputPluginTest
 
class  WindowsLifecycleManagerTest
 

Functions

 TEST (AccessibilityBridgeWindows, GetParent)
 
 TEST (AccessibilityBridgeWindows, GetParentOnRootRetunsNullptr)
 
 TEST (AccessibilityBridgeWindows, DispatchAccessibilityAction)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityEventAlert)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityEventChildrenChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityEventFocusChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityEventIgnoredChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityImageAnnotationChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityLiveRegionChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityNameChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityHScrollPosChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityVScrollPosChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilitySelectedChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilitySelectedChildrenChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilitySubtreeCreated)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityValueChanged)
 
 TEST (AccessibilityBridgeWindows, OnAccessibilityStateChanged)
 
 TEST (AccessibilityBridgeWindows, OnDocumentSelectionChanged)
 
 TEST_F (AccessibilityPluginTest, DirectAnnounceCall)
 
 TEST_F (AccessibilityPluginTest, AnnounceWithInt32ViewId)
 
 TEST_F (AccessibilityPluginTest, AnnounceWithInt64ViewId)
 
 TEST_F (AccessibilityPluginTest, AnnounceWithInvalidViewIdType)
 
 TEST_F (AccessibilityPluginTest, AnnounceWithMissingMessage)
 
 TEST_F (CompositorOpenGLTest, CreateBackingStore)
 
 TEST_F (CompositorOpenGLTest, CreateBackingStoreImpeller)
 
 TEST_F (CompositorOpenGLTest, InitializationFailure)
 
 TEST_F (CompositorOpenGLTest, InitializationRequiresBlit)
 
 TEST_F (CompositorOpenGLTest, Present)
 
 TEST_F (CompositorOpenGLTest, PresentEmpty)
 
 TEST_F (CompositorOpenGLTest, NoSurfaceIgnored)
 
 TEST_F (CompositorOpenGLTest, PresentUsingANGLEBlitExtension)
 
 TEST_F (CompositorSoftwareTest, CreateBackingStore)
 
 TEST_F (CompositorSoftwareTest, Present)
 
 TEST_F (CompositorSoftwareTest, PresentEmpty)
 
 TEST_F (CompositorSoftwareTest, PresentMultiLayers)
 
 TEST_F (CompositorSoftwareTest, PresentOffsetLayers)
 
 TEST_F (CursorHandlerTest, ActivateSystemCursor)
 
 TEST_F (CursorHandlerTest, CreateCustomCursor)
 
 TEST_F (CursorHandlerTest, SetCustomCursor)
 
 TEST_F (CursorHandlerTest, SetNonexistentCustomCursor)
 
 TEST_F (CursorHandlerTest, DeleteCustomCursor)
 
 TEST_F (CursorHandlerTest, DeleteNonexistentCustomCursor)
 
 TEST (DirectManipulationTest, TestGesture)
 
 TEST (DirectManipulationTest, TestRounding)
 
 TEST (DirectManipulationTest, TestInertiaCancelSentForUserCancel)
 
 TEST (DirectManipulationTest, TestInertiaCamcelNotSentAtInertiaEnd)
 
 TEST (DirectManipulationTest, TestGestureWithInitialData)
 
 TEST_F (DisplayManagerWin32Test, MultipleMonitors)
 
 TEST_F (DisplayManagerWin32Test, HandleDisplayChangeMessage)
 
 TEST (DpiUtilsTest, NonZero)
 
 TEST (DpiUtilsTest, NullHwndUsesPrimaryMonitor)
 
 TEST (FlutterProjectBundle, BasicPropertiesAbsolutePaths)
 
 TEST (FlutterProjectBundle, BasicPropertiesRelativePaths)
 
 TEST (FlutterProjectBundle, SwitchesEmpty)
 
 TEST (FlutterProjectBundle, DartEntrypointArguments)
 
 TEST (FlutterProjectBundle, Switches)
 
 TEST_F (FlutterWindowTest, CreateDestroy)
 
 TEST_F (FlutterWindowTest, OnBitmapSurfaceUpdated)
 
 TEST_F (FlutterWindowTest, OnCursorRectUpdatedRegularDPI)
 
 TEST_F (FlutterWindowTest, OnCursorRectUpdatedHighDPI)
 
 TEST_F (FlutterWindowTest, OnPointerStarSendsDeviceType)
 
 TEST_F (FlutterWindowTest, OnScrollCallsGetScrollOffsetMultiplier)
 
 TEST_F (FlutterWindowTest, OnWindowRepaint)
 
 TEST_F (FlutterWindowTest, OnThemeChange)
 
 TEST_F (FlutterWindowTest, AccessibilityNodeWithoutView)
 
 TEST_F (FlutterWindowTest, AlertNode)
 
 TEST_F (FlutterWindowTest, LifecycleFocusMessages)
 
 TEST_F (FlutterWindowTest, CachedLifecycleMessage)
 
 TEST_F (FlutterWindowsEngineTest, RunHeadless)
 
 TEST_F (FlutterWindowsEngineTest, TaskRunnerDelayedTask)
 
 TEST_F (FlutterWindowsEngineTest, TaskRunnerDoesNotDeadlock)
 
 TEST_F (FlutterWindowsEngineTest, RunDoesExpectedInitialization)
 
 TEST_F (FlutterWindowsEngineTest, ConfiguresFrameVsync)
 
 TEST_F (FlutterWindowsEngineTest, RunWithoutANGLEUsesSoftware)
 
 TEST_F (FlutterWindowsEngineTest, RunWithoutANGLEOnImpellerFailsToStart)
 
 TEST_F (FlutterWindowsEngineTest, SendPlatformMessageWithoutResponse)
 
 TEST_F (FlutterWindowsEngineTest, PlatformMessageRoundTrip)
 
 TEST_F (FlutterWindowsEngineTest, PlatformMessageRespondOnDifferentThread)
 
 TEST_F (FlutterWindowsEngineTest, SendPlatformMessageWithResponse)
 
 TEST_F (FlutterWindowsEngineTest, DispatchSemanticsAction)
 
 TEST_F (FlutterWindowsEngineTest, SetsThreadPriority)
 
 TEST_F (FlutterWindowsEngineTest, AddPluginRegistrarDestructionCallback)
 
 TEST_F (FlutterWindowsEngineTest, ScheduleFrame)
 
 TEST_F (FlutterWindowsEngineTest, SetNextFrameCallback)
 
 TEST_F (FlutterWindowsEngineTest, GetExecutableName)
 
 TEST_F (FlutterWindowsEngineTest, UpdateHighContrastFeature)
 
 TEST_F (FlutterWindowsEngineTest, PostRasterThreadTask)
 
 TEST_F (FlutterWindowsEngineTest, AccessibilityAnnouncement)
 
 TEST_F (FlutterWindowsEngineTest, AccessibilityAnnouncementHeadless)
 
 TEST_F (FlutterWindowsEngineTest, AccessibilityTooltip)
 
 TEST_F (FlutterWindowsEngineTest, TestExit)
 
 TEST_F (FlutterWindowsEngineTest, TestExitCancel)
 
 TEST_F (FlutterWindowsEngineTest, TestExitSecondCloseMessage)
 
 TEST_F (FlutterWindowsEngineTest, TestExitCloseMultiWindow)
 
 TEST_F (FlutterWindowsEngineTest, LifecycleManagerDisabledByDefault)
 
 TEST_F (FlutterWindowsEngineTest, EnableApplicationLifecycle)
 
 TEST_F (FlutterWindowsEngineTest, ApplicationLifecycleExternalWindow)
 
 TEST_F (FlutterWindowsEngineTest, LifecycleStateTransition)
 
 TEST_F (FlutterWindowsEngineTest, ExternalWindowMessage)
 
 TEST_F (FlutterWindowsEngineTest, InnerWindowHidden)
 
 TEST_F (FlutterWindowsEngineTest, EnableLifecycleState)
 
 TEST_F (FlutterWindowsEngineTest, LifecycleStateToFrom)
 
 TEST_F (FlutterWindowsEngineTest, ChannelListenedTo)
 
 TEST_F (FlutterWindowsEngineTest, ReceivePlatformViewMessage)
 
 TEST_F (FlutterWindowsEngineTest, AddViewFailureDoesNotHang)
 
 TEST_F (FlutterWindowsEngineTest, RemoveViewFailureDoesNotHang)
 
 TEST_F (FlutterWindowsEngineTest, MergedUIThread)
 
 TEST_F (FlutterWindowsEngineTest, OnViewFocusChangeRequest)
 
 TEST_F (FlutterWindowsEngineTest, UpdateSemanticsMultiView)
 
 TEST (FlutterWindowsTextureRegistrarTest, CreateDestroy)
 
 TEST (FlutterWindowsTextureRegistrarTest, RegisterUnregisterTexture)
 
 TEST (FlutterWindowsTextureRegistrarTest, RegisterUnknownTextureType)
 
 TEST (FlutterWindowsTextureRegistrarTest, PopulatePixelBufferTexture)
 
 TEST (FlutterWindowsTextureRegistrarTest, PopulateD3dTextureWithHandle)
 
 TEST (FlutterWindowsTextureRegistrarTest, PopulateD3dTexture)
 
 TEST (FlutterWindowsTextureRegistrarTest, PopulateInvalidTexture)
 
 TEST (FlutterWindowsTextureRegistrarTest, UnregisterTextureWithEngineDownInvokesCallback)
 
 TEST (WindowsNoFixtureTest, GetTextureRegistrar)
 
 TEST_F (WindowsTest, LaunchMain)
 
 TEST_F (WindowsTest, LaunchMainHasNoOutput)
 
 TEST_F (WindowsTest, LaunchCustomEntrypoint)
 
 TEST_F (WindowsTest, LaunchCustomEntrypointInEngineRunInvocation)
 
 TEST_F (WindowsTest, LaunchHeadlessEngine)
 
 TEST_F (WindowsTest, EngineCanTransitionToHeadless)
 
 TEST_F (WindowsTest, LaunchRefreshesAccessibility)
 
 TEST_F (WindowsTest, LaunchConflictingCustomEntrypoints)
 
 TEST_F (WindowsTest, VerifyNativeFunction)
 
 TEST_F (WindowsTest, VerifyNativeFunctionWithParameters)
 
 TEST_F (WindowsTest, PlatformExecutable)
 
 TEST_F (WindowsTest, VerifyNativeFunctionWithReturn)
 
 TEST_F (WindowsTest, NextFrameCallback)
 
 TEST_F (WindowsTest, PresentHeadless)
 
 TEST_F (WindowsTest, GetViewId)
 
 TEST_F (WindowsTest, GetGraphicsAdapter)
 
 TEST_F (WindowsTest, GetGraphicsAdapterWithLowPowerPreference)
 
 TEST_F (WindowsTest, GetGraphicsAdapterWithHighPerformancePreference)
 
 TEST_F (WindowsTest, PluginRegistrarGetImplicitView)
 
 TEST_F (WindowsTest, PluginRegistrarGetView)
 
 TEST_F (WindowsTest, PluginRegistrarGetViewHeadless)
 
 TEST_F (WindowsTest, SurfaceOptional)
 
 TEST_F (WindowsTest, Lifecycle)
 
 TEST_F (WindowsTest, GetKeyboardStateHeadless)
 
 TEST_F (WindowsTest, AddRemoveView)
 
 TEST_F (WindowsTest, EngineId)
 
 TEST (FlutterWindowsViewTest, SubMenuExpandedState)
 
 TEST (FlutterWindowsViewTest, Shutdown)
 
 TEST (FlutterWindowsViewTest, KeySequence)
 
 TEST (FlutterWindowsViewTest, KeyEventCallback)
 
 TEST (FlutterWindowsViewTest, EnableSemantics)
 
 TEST (FlutterWindowsViewTest, AddSemanticsNodeUpdate)
 
 TEST (FlutterWindowsViewTest, AddSemanticsNodeUpdateWithChildren)
 
 TEST (FlutterWindowsViewTest, NonZeroSemanticsRoot)
 
 TEST (FlutterWindowsViewTest, AccessibilityHitTesting)
 
 TEST (FlutterWindowsViewTest, WindowResizeTests)
 
 TEST (FlutterWindowsViewTest, TestEmptyFrameResizes)
 
 TEST (FlutterWindowsViewTest, WindowResizeRace)
 
 TEST (FlutterWindowsViewTest, WindowResizeInvalidSurface)
 
 TEST (FlutterWindowsViewTest, WindowResizeWithoutSurface)
 
 TEST (FlutterWindowsViewTest, WindowRepaintTests)
 
 TEST (FlutterWindowsViewTest, CheckboxNativeState)
 
 TEST (FlutterWindowsViewTest, SwitchNativeState)
 
 TEST (FlutterWindowsViewTest, TooltipNodeData)
 
 TEST (FlutterWindowsViewTest, DisablesVSyncAtStartup)
 
 TEST (FlutterWindowsViewTest, EnablesVSyncAtStartup)
 
 TEST (FlutterWindowsViewTest, DisablesVSyncAfterStartup)
 
 TEST (FlutterWindowsViewTest, EnablesVSyncAfterStartup)
 
 TEST (FlutterWindowsViewTest, UpdatesVSyncOnDwmUpdates)
 
 TEST (FlutterWindowsViewTest, FocusTriggersWindowFocus)
 
 TEST (FlutterWindowsViewTest, OnFocusTriggersSendFocusViewEvent)
 
 TEST (FlutterWindowsViewTest, WindowMetricsEventContainsDisplayId)
 
 TEST (FlutterWindowsViewTest, SizeChangeTriggersMetricsEventWhichHasDisplayId)
 
 TEST (KeyboardKeyChannelHandlerTest, KeyboardHookHandling)
 
 TEST (KeyboardKeyChannelHandlerTest, ExtendedKeysAreSentToRedispatch)
 
 TEST (KeyboardKeyChannelHandlerTest, DeadKeysDoNotCrash)
 
 TEST (KeyboardKeyChannelHandlerTest, EmptyResponsesDoNotCrash)
 
 TEST (KeyboardKeyEmbedderHandlerTest, ConvertChar32ToUtf8)
 
 TEST (KeyboardKeyEmbedderHandlerTest, BasicKeyPressingAndHolding)
 
 TEST (KeyboardKeyEmbedderHandlerTest, ToggleNumLockDuringNumpadPress)
 
 TEST (KeyboardKeyEmbedderHandlerTest, ImeEventsAreIgnored)
 
 TEST (KeyboardKeyEmbedderHandlerTest, ModifierKeysByExtendedBit)
 
 TEST (KeyboardKeyEmbedderHandlerTest, ModifierKeysByVirtualKey)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeModifierLeftKeyDownWhenNotPressed)
 
 TEST (KeyboardKeyEmbedderHandlerTest, DoNotSynthesizeModifierDownWhenPressed)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeModifierUpWhenPressed)
 
 TEST (KeyboardKeyEmbedderHandlerTest, DoNotSynthesizeModifierUpWhenNotPressed)
 
 TEST (KeyboardKeyEmbedderHandlerTest, RepeatedDownIsIgnored)
 
 TEST (KeyboardKeyEmbedderHandlerTest, AbruptRepeatIsConvertedToDown)
 
 TEST (KeyboardKeyEmbedderHandlerTest, AbruptUpIsIgnored)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncPressingState)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncToggledState)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncToggledStateByItselfsUp)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncToggledStateByItselfsDown)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeWithInitialTogglingState)
 
 TEST (KeyboardKeyEmbedderHandlerTest, SysKeyPress)
 
 TEST (KeyboardKeyHandlerTest, SingleDelegateWithAsyncResponds)
 
 TEST (KeyboardKeyHandlerTest, SingleDelegateWithSyncResponds)
 
 TEST (KeyboardKeyHandlerTest, HandlerGetPressedState)
 
 TEST (KeyboardKeyHandlerTest, KeyboardChannelGetPressedState)
 
 TEST_F (KeyboardTest, LowerCaseAHandled)
 
 TEST_F (KeyboardTest, LowerCaseAUnhandled)
 
 TEST_F (KeyboardTest, ArrowLeftHandled)
 
 TEST_F (KeyboardTest, ArrowLeftUnhandled)
 
 TEST_F (KeyboardTest, ShiftLeftUnhandled)
 
 TEST_F (KeyboardTest, ShiftRightUnhandled)
 
 TEST_F (KeyboardTest, CtrlLeftUnhandled)
 
 TEST_F (KeyboardTest, CtrlRightUnhandled)
 
 TEST_F (KeyboardTest, AltLeftUnhandled)
 
 TEST_F (KeyboardTest, AltRightUnhandled)
 
 TEST_F (KeyboardTest, MetaLeftUnhandled)
 
 TEST_F (KeyboardTest, MetaRightUnhandled)
 
 TEST_F (KeyboardTest, RepeatA)
 
 TEST_F (KeyboardTest, RestartClearsKeyboardState)
 
 TEST_F (KeyboardTest, FreshKeyDownAfterMissedUpIsDelivered)
 
 TEST_F (KeyboardTest, ShiftLeftKeyA)
 
 TEST_F (KeyboardTest, CtrlLeftKeyA)
 
 TEST_F (KeyboardTest, CtrlLeftDigit1)
 
 TEST_F (KeyboardTest, Digit1OnFrenchLayout)
 
 TEST_F (KeyboardTest, AltGrModifiedKey)
 
 TEST_F (KeyboardTest, AltGrTwice)
 
 TEST_F (KeyboardTest, DeadKeyThatCombines)
 
 TEST_F (KeyboardTest, DeadKeyWithoutDeadMaskThatCombines)
 
 TEST_F (KeyboardTest, DeadKeyThatDoesNotCombine)
 
 TEST_F (KeyboardTest, DeadKeyTwiceThenLetter)
 
 TEST_F (KeyboardTest, MultibyteCharacter)
 
 TEST_F (KeyboardTest, SynthesizeModifiers)
 
 TEST_F (KeyboardTest, ImeExtendedEventsAreIgnored)
 
 TEST_F (KeyboardTest, UpOnlyImeEventsAreCorrectlyHandled)
 
 TEST_F (KeyboardTest, SlowFrameworkResponse)
 
 TEST_F (KeyboardTest, SlowFrameworkResponseForIdenticalEvents)
 
 TEST_F (KeyboardTest, TextInputSubmit)
 
 TEST_F (KeyboardTest, VietnameseTelexAddDiacriticWithFastResponse)
 
void VietnameseTelexAddDiacriticWithSlowResponse (WindowsTestContext &context, bool backspace_response)
 
 TEST_F (KeyboardTest, VietnameseTelexAddDiacriticWithSlowFalseResponse)
 
 TEST_F (KeyboardTest, VietnameseTelexAddDiacriticWithSlowTrueResponse)
 
 TEST_F (KeyboardTest, DoubleCapsLock)
 
 TEST (KeyboardWin32CommonTest, EncodeUtf16)
 
 TEST_F (PlatformHandlerTest, GetClipboardData)
 
 TEST_F (PlatformHandlerTest, GetClipboardDataRejectsUnknownContentType)
 
 TEST_F (PlatformHandlerTest, GetClipboardDataReportsOpenFailure)
 
 TEST_F (PlatformHandlerTest, GetClipboardDataReportsGetDataFailure)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStrings)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsReturnsFalse)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsRejectsUnknownContentType)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsIgnoresPermissionErrors)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsReportsErrors)
 
 TEST_F (PlatformHandlerTest, ClipboardSetData)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataTextMustBeString)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataUnknownType)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataReportsOpenFailure)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataReportsSetDataFailure)
 
 TEST_F (PlatformHandlerTest, PlaySystemSound)
 
 TEST_F (PlatformHandlerTest, SystemExitApplicationRequired)
 
 TEST_F (PlatformHandlerTest, SystemExitApplicationCancelableCancel)
 
 TEST_F (PlatformHandlerTest, SystemExitApplicationCancelableExit)
 
 TEST (SequentialIdGeneratorTest, RemoveMultipleNumbers)
 
 TEST (SequentialIdGeneratorTest, MaybeRemoveNumbers)
 
 TEST (SettingsPluginTest, SendSettingsSendsMessage)
 
 TEST (SettingsPluginTest, SendSettingsGetsSettings)
 
 TEST (SettingsPluginTest, StartWatchingStartsWatchingChanges)
 
 TEST (SettingsPluginTest, HighContrastModeHonored)
 
 TEST (SystemUtils, GetPreferredLanguageInfo)
 
 TEST (SystemUtils, GetPreferredLanguages)
 
 TEST (SystemUtils, ParseLanguageNameGeneric)
 
 TEST (SystemUtils, ParseLanguageNameWithRegion)
 
 TEST (SystemUtils, ParseLanguageNameWithScript)
 
 TEST (SystemUtils, ParseLanguageNameWithRegionAndScript)
 
 TEST (SystemUtils, ParseLanguageNameWithSuplementalLanguage)
 
 TEST (SystemUtils, ParseLanguageNameWithThreeCharacterLanguage)
 
 TEST (SystemUtils, GetUserTimeFormat)
 
 TEST (SystemUtils, Prefer24HourTimeHandlesEmptyFormat)
 
 TEST (SystemUtils, Prefer24HourTimeHandles12Hour)
 
 TEST (SystemUtils, Prefer24HourTimeHandles24Hour)
 
 TEST (TaskRunnerTest, MaybeExecuteTaskWithExactOrder)
 
 TEST (TaskRunnerTest, MaybeExecuteTaskOnlyExpired)
 
 TEST (TaskRunnerTest, TimerThreadDoesNotCancelEarlierScheduledTasks)
 
 TEST (TaskRunnerTest, TaskRunnerWindowCoalescesWakeUpMessages)
 
 TEST_F (TextInputPluginTest, TextMethodsWorksWithEmptyModel)
 
 TEST_F (TextInputPluginTest, ClearClientResetsComposing)
 
 TEST_F (TextInputPluginTest, ClearClientRequiresView)
 
 TEST_F (TextInputPluginTest, VerifyComposingSendStateUpdate)
 
 TEST_F (TextInputPluginTest, VerifyInputActionNewlineInsertNewLine)
 
 TEST_F (TextInputPluginTest, VerifyInputActionSendDoesNotInsertNewLine)
 
 TEST_F (TextInputPluginTest, SetClientRequiresViewId)
 
 TEST_F (TextInputPluginTest, SetClientRequiresViewIdToBeInteger)
 
 TEST_F (TextInputPluginTest, TextEditingWorksWithDeltaModel)
 
 TEST_F (TextInputPluginTest, CompositionCursorPos)
 
 TEST_F (TextInputPluginTest, TransformCursorRect)
 
 TEST_F (TextInputPluginTest, SetMarkedTextRectRequiresView)
 
 TEST_F (TextInputPluginTest, SetAndUseMultipleClients)
 
 TEST_F (WindowManagerTest, WindowingInitialize)
 
 TEST_F (WindowManagerTest, CreateRegularWindow)
 
 TEST_F (WindowManagerTest, GetWindowHandle)
 
 TEST_F (WindowManagerTest, GetWindowSize)
 
 TEST_F (WindowManagerTest, SetWindowSize)
 
 TEST_F (WindowManagerTest, CanConstrainByMinimiumSize)
 
 TEST_F (WindowManagerTest, CanConstrainByMaximumSize)
 
 TEST_F (WindowManagerTest, CanFullscreenWindow)
 
 TEST_F (WindowManagerTest, CanUnfullscreenWindow)
 
 TEST_F (WindowManagerTest, CanSetWindowSizeWhileFullscreen)
 
 TEST_F (WindowManagerTest, CanSetWindowConstraintsWhileFullscreen)
 
 TEST_F (WindowManagerTest, CreateModelessDialogWindow)
 
 TEST_F (WindowManagerTest, CreateModalDialogWindow)
 
 TEST_F (WindowManagerTest, DialogCanNeverBeFullscreen)
 
 TEST_F (WindowManagerTest, CreateTooltipWindow)
 
 TEST_F (WindowManagerTest, TooltipWindowHasNoActivateStyle)
 
 TEST_F (WindowManagerTest, TooltipWindowDoesNotStealFocus)
 
 TEST_F (WindowManagerTest, TooltipWindowReturnsNoActivateOnMouseClick)
 
 TEST_F (WindowManagerTest, TooltipWindowUpdatesPositionOnViewSizeChange)
 
 TEST (WindowProcDelegateManagerTest, CallsCorrectly)
 
 TEST (WindowProcDelegateManagerTest, ReplacementRegister)
 
 TEST (WindowProcDelegateManagerTest, RegisterMultiple)
 
 TEST (WindowProcDelegateManagerTest, Ordered)
 
 TEST (WindowProcDelegateManagerTest, ConflictingDelegates)
 
 TEST (WindowProcDelegateManagerTest, Unregister)
 
 TEST (MockWindow, CreateDestroy)
 
 TEST (MockWindow, GetDpiAfterCreate)
 
 TEST (MockWindow, VerticalScroll)
 
 TEST (MockWindow, OnImeCompositionCompose)
 
 TEST (MockWindow, OnImeCompositionResult)
 
 TEST (MockWindow, OnImeCompositionResultAndCompose)
 
 TEST (MockWindow, OnImeCompositionClearChange)
 
 TEST (MockWindow, HorizontalScroll)
 
 TEST (MockWindow, MouseLeave)
 
 TEST (MockWindow, KeyDown)
 
 TEST (MockWindow, KeyUp)
 
 TEST (MockWindow, SysKeyDown)
 
 TEST (MockWindow, SysKeyUp)
 
 TEST (MockWindow, KeyDownPrintable)
 
 TEST (MockWindow, KeyDownWithCtrl)
 
 TEST (MockWindow, KeyDownWithCtrlToggled)
 
 TEST (MockWindow, Paint)
 
 TEST (MockWindow, PointerHitTest)
 
 TEST (MockWindow, TouchPadHitTest)
 
 TEST (MockWindow, UnknownPointerTypeSkipsDirectManipulation)
 
 TEST (MockWindow, DISABLED_GetObjectUia)
 
static void WaitUntilUpdated (const WindowsLifecycleManager &manager)
 
 TEST_F (WindowsLifecycleManagerTest, StateTransitions)
 
FlutterSemanticsNode2 CreateSemanticsNode (int32_t id, const char *label, const std::vector< int32_t > *children=nullptr)
 
 TEST (AccessibilityBridgeTest, BasicTest)
 
 TEST (AccessibilityBridgeTest, AccessibilityRootId)
 
 TEST (AccessibilityBridgeTest, AddOrder)
 
 TEST (AccessibilityBridgeTest, CanFireChildrenChangedCorrectly)
 
 TEST (AccessibilityBridgeTest, CanHandleSelectionChangeCorrectly)
 
 TEST (AccessibilityBridgeTest, DoesNotAssignEditableRootToSelectableText)
 
 TEST (AccessibilityBridgeTest, SwitchHasSwitchRole)
 
 TEST (AccessibilityBridgeTest, SliderHasSliderRole)
 
 TEST (AccessibilityBridgeTest, CanSetCheckboxChecked)
 
 TEST (AccessibilityBridgeTest, CanReparentNode)
 
 TEST (AccessibilityBridgeTest, CanReparentMultipleNodes)
 
 TEST (AccessibilityBridgeTest, CanReparentNodeWithChild)
 
 TEST (AccessibilityBridgeTest, AXTreeManagerTest)
 
 TEST (AccessibilityBridgeTest, LineBreakingObjectTest)
 
 TEST (FlutterPlatformNodeDelegateTest, NodeDelegateHasUniqueId)
 
 TEST (FlutterPlatformNodeDelegateTest, canPerfomActions)
 
 TEST (FlutterPlatformNodeDelegateTest, canGetAXNode)
 
 TEST (FlutterPlatformNodeDelegateTest, canCalculateBoundsCorrectly)
 
 TEST (FlutterPlatformNodeDelegateTest, canCalculateOffScreenBoundsCorrectly)
 
 TEST (FlutterPlatformNodeDelegateTest, canUseOwnerBridge)
 
 TEST (FlutterPlatformNodeDelegateTest, selfIsLowestPlatformAncestor)
 
 TEST (FlutterPlatformNodeDelegateTest, canGetFromNodeID)
 

Variables

constexpr uint64_t kScanCodeKeyA = 0x1e
 
constexpr uint64_t kVirtualKeyA = 0x41
 
FlutterSemanticsFlags kEmptyFlags = FlutterSemanticsFlags{}
 

Function Documentation

◆ CreateSemanticsNode()

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

Definition at line 20 of file accessibility_bridge_unittests.cc.

23  {
24  return {
25  .id = id,
26  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
27  .flags__deprecated__ = static_cast<FlutterSemanticsFlag>(0),
28  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
29  .actions = static_cast<FlutterSemanticsAction>(0),
30  .text_selection_base = -1,
31  .text_selection_extent = -1,
32  .label = label,
33  .hint = "",
34  .value = "",
35  .increased_value = "",
36  .decreased_value = "",
37  .child_count = children ? children->size() : 0,
38  .children_in_traversal_order = children ? children->data() : nullptr,
39  .custom_accessibility_actions_count = 0,
40  .tooltip = "",
41  .flags2 = &kEmptyFlags,
42  };
43 }
flutter::testing::kEmptyFlags
FlutterSemanticsFlags kEmptyFlags
Definition: accessibility_bridge_unittests.cc:18

References kEmptyFlags.

Referenced by TEST().

◆ TEST() [1/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
AccessibilityRootId   
)

Definition at line 79 of file accessibility_bridge_unittests.cc.

79  {
80  std::shared_ptr<TestAccessibilityBridge> bridge =
81  std::make_shared<TestAccessibilityBridge>();
82 
83  std::vector<int32_t> children{456, 789};
84  FlutterSemanticsNode2 root = CreateSemanticsNode(123, "root", &children);
85  FlutterSemanticsNode2 child1 = CreateSemanticsNode(456, "child 1");
86  FlutterSemanticsNode2 child2 = CreateSemanticsNode(789, "child 2");
87 
88  bridge->AddFlutterSemanticsNodeUpdate(root);
89  bridge->AddFlutterSemanticsNodeUpdate(child1);
90  bridge->AddFlutterSemanticsNodeUpdate(child2);
91  bridge->CommitUpdates();
92 
93  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(123).lock();
94  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(456).lock();
95  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(789).lock();
96  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
97 
98  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 123);
99  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
100 
101  EXPECT_EQ(root_node->GetChildCount(), 2);
102  EXPECT_EQ(root_node->GetData().child_ids[0], 456);
103  EXPECT_EQ(root_node->GetData().child_ids[1], 789);
104  EXPECT_EQ(root_node->GetName(), "root");
105 
106  EXPECT_EQ(child1_node->GetChildCount(), 0);
107  EXPECT_EQ(child1_node->GetName(), "child 1");
108 
109  EXPECT_EQ(child2_node->GetChildCount(), 0);
110  EXPECT_EQ(child2_node->GetName(), "child 2");
111 
112  ASSERT_FALSE(fake_delegate);
113 }
flutter::testing::CreateSemanticsNode
FlutterSemanticsNode2 CreateSemanticsNode(int32_t id, const char *label, const std::vector< int32_t > *children=nullptr)
Definition: accessibility_bridge_unittests.cc:20

References CreateSemanticsNode().

◆ TEST() [2/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
AddOrder   
)

Definition at line 116 of file accessibility_bridge_unittests.cc.

116  {
117  std::shared_ptr<TestAccessibilityBridge> bridge =
118  std::make_shared<TestAccessibilityBridge>();
119 
120  std::vector<int32_t> root_children{34, 56};
121  std::vector<int32_t> child2_children{78};
122  std::vector<int32_t> child3_children{90};
123  FlutterSemanticsNode2 root = CreateSemanticsNode(12, "root", &root_children);
124  FlutterSemanticsNode2 child1 = CreateSemanticsNode(34, "child 1");
125  FlutterSemanticsNode2 child2 =
126  CreateSemanticsNode(56, "child 2", &child2_children);
127  FlutterSemanticsNode2 child3 =
128  CreateSemanticsNode(78, "child 3", &child3_children);
129  FlutterSemanticsNode2 child4 = CreateSemanticsNode(90, "child 4");
130 
131  bridge->AddFlutterSemanticsNodeUpdate(child3);
132  bridge->AddFlutterSemanticsNodeUpdate(child2);
133  bridge->AddFlutterSemanticsNodeUpdate(root);
134  bridge->AddFlutterSemanticsNodeUpdate(child1);
135  bridge->AddFlutterSemanticsNodeUpdate(child4);
136  bridge->CommitUpdates();
137 
138  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(12).lock();
139  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(34).lock();
140  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(56).lock();
141  auto child3_node = bridge->GetFlutterPlatformNodeDelegateFromID(78).lock();
142  auto child4_node = bridge->GetFlutterPlatformNodeDelegateFromID(90).lock();
143 
144  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 12);
145  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
146 
147  EXPECT_EQ(root_node->GetChildCount(), 2);
148  EXPECT_EQ(root_node->GetData().child_ids[0], 34);
149  EXPECT_EQ(root_node->GetData().child_ids[1], 56);
150  EXPECT_EQ(root_node->GetName(), "root");
151 
152  EXPECT_EQ(child1_node->GetChildCount(), 0);
153  EXPECT_EQ(child1_node->GetName(), "child 1");
154 
155  EXPECT_EQ(child2_node->GetChildCount(), 1);
156  EXPECT_EQ(child2_node->GetData().child_ids[0], 78);
157  EXPECT_EQ(child2_node->GetName(), "child 2");
158 
159  EXPECT_EQ(child3_node->GetChildCount(), 1);
160  EXPECT_EQ(child3_node->GetData().child_ids[0], 90);
161  EXPECT_EQ(child3_node->GetName(), "child 3");
162 
163  EXPECT_EQ(child4_node->GetChildCount(), 0);
164  EXPECT_EQ(child4_node->GetName(), "child 4");
165 }

References CreateSemanticsNode().

◆ TEST() [3/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
AXTreeManagerTest   
)

Definition at line 566 of file accessibility_bridge_unittests.cc.

566  {
567  std::shared_ptr<TestAccessibilityBridge> bridge =
568  std::make_shared<TestAccessibilityBridge>();
569 
570  ui::AXTreeID tree_id = bridge->GetTreeID();
571  ui::AXTreeManager* manager =
572  ui::AXTreeManagerMap::GetInstance().GetManager(tree_id);
573  ASSERT_EQ(manager, static_cast<ui::AXTreeManager*>(bridge.get()));
574 }

◆ TEST() [4/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
BasicTest   
)

Definition at line 45 of file accessibility_bridge_unittests.cc.

45  {
46  std::shared_ptr<TestAccessibilityBridge> bridge =
47  std::make_shared<TestAccessibilityBridge>();
48 
49  std::vector<int32_t> children{1, 2};
50  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
51  root.identifier = "identifier";
52  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
53  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
54 
55  bridge->AddFlutterSemanticsNodeUpdate(root);
56  bridge->AddFlutterSemanticsNodeUpdate(child1);
57  bridge->AddFlutterSemanticsNodeUpdate(child2);
58  bridge->CommitUpdates();
59 
60  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
61  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
62  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
63  EXPECT_EQ(root_node->GetChildCount(), 2);
64  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
65  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
66  EXPECT_EQ(root_node->GetName(), "root");
67  EXPECT_EQ(root_node->GetAuthorUniqueId(), u"identifier");
68 
69  EXPECT_EQ(child1_node->GetChildCount(), 0);
70  EXPECT_EQ(child1_node->GetName(), "child 1");
71 
72  EXPECT_EQ(child2_node->GetChildCount(), 0);
73  EXPECT_EQ(child2_node->GetName(), "child 2");
74 }

References CreateSemanticsNode().

◆ TEST() [5/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanFireChildrenChangedCorrectly   
)

Definition at line 167 of file accessibility_bridge_unittests.cc.

167  {
168  std::shared_ptr<TestAccessibilityBridge> bridge =
169  std::make_shared<TestAccessibilityBridge>();
170 
171  std::vector<int32_t> children{1};
172  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
173  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
174 
175  bridge->AddFlutterSemanticsNodeUpdate(root);
176  bridge->AddFlutterSemanticsNodeUpdate(child1);
177 
178  bridge->CommitUpdates();
179 
180  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
181  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
182  EXPECT_EQ(root_node->GetChildCount(), 1);
183  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
184  EXPECT_EQ(root_node->GetName(), "root");
185 
186  EXPECT_EQ(child1_node->GetChildCount(), 0);
187  EXPECT_EQ(child1_node->GetName(), "child 1");
188  bridge->accessibility_events.clear();
189 
190  // Add a child to root.
191  root.child_count = 2;
192  int32_t new_children[] = {1, 2};
193  root.children_in_traversal_order = new_children;
194 
195  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
196 
197  bridge->AddFlutterSemanticsNodeUpdate(root);
198  bridge->AddFlutterSemanticsNodeUpdate(child2);
199  bridge->CommitUpdates();
200 
201  root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
202 
203  EXPECT_EQ(root_node->GetChildCount(), 2);
204  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
205  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
206  EXPECT_EQ(bridge->accessibility_events.size(), size_t{2});
207  std::set<ui::AXEventGenerator::Event> actual_event{
208  bridge->accessibility_events.begin(), bridge->accessibility_events.end()};
209  EXPECT_THAT(actual_event,
210  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED));
211  EXPECT_THAT(actual_event,
212  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED));
213 }

References CreateSemanticsNode().

◆ TEST() [6/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanHandleSelectionChangeCorrectly   
)

Definition at line 215 of file accessibility_bridge_unittests.cc.

215  {
216  std::shared_ptr<TestAccessibilityBridge> bridge =
217  std::make_shared<TestAccessibilityBridge>();
218  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
219  auto flags = FlutterSemanticsFlags{
220  .is_focused = FlutterTristate::kFlutterTristateTrue,
221  .is_text_field = true,
222  };
223  root.flags2 = &flags;
224 
225  bridge->AddFlutterSemanticsNodeUpdate(root);
226  bridge->CommitUpdates();
227 
228  const ui::AXTreeData& tree = bridge->GetAXTreeData();
229  EXPECT_EQ(tree.sel_anchor_object_id, ui::AXNode::kInvalidAXID);
230  bridge->accessibility_events.clear();
231 
232  // Update the selection.
233  root.text_selection_base = 0;
234  root.text_selection_extent = 5;
235  bridge->AddFlutterSemanticsNodeUpdate(root);
236 
237  bridge->CommitUpdates();
238 
239  EXPECT_EQ(tree.sel_anchor_object_id, 0);
240  EXPECT_EQ(tree.sel_anchor_offset, 0);
241  EXPECT_EQ(tree.sel_focus_object_id, 0);
242  EXPECT_EQ(tree.sel_focus_offset, 5);
243  ASSERT_EQ(bridge->accessibility_events.size(), size_t{2});
244  EXPECT_EQ(bridge->accessibility_events[0],
245  ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED);
246  EXPECT_EQ(bridge->accessibility_events[1],
247  ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED);
248 }

References CreateSemanticsNode().

◆ TEST() [7/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanReparentMultipleNodes   
)

Definition at line 392 of file accessibility_bridge_unittests.cc.

392  {
393  std::shared_ptr<TestAccessibilityBridge> bridge =
394  std::make_shared<TestAccessibilityBridge>();
395 
396  int32_t root_id = 0;
397  int32_t intermediary1_id = 1;
398  int32_t intermediary2_id = 2;
399  int32_t leaf1_id = 3;
400  int32_t leaf2_id = 4;
401  int32_t leaf3_id = 5;
402 
403  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
404  std::vector<int32_t> intermediary1_children{leaf1_id};
405  std::vector<int32_t> intermediary2_children{leaf2_id, leaf3_id};
406  FlutterSemanticsNode2 root =
407  CreateSemanticsNode(root_id, "root", &root_children);
408  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
409  intermediary1_id, "intermediary 1", &intermediary1_children);
410  FlutterSemanticsNode2 intermediary2 = CreateSemanticsNode(
411  intermediary2_id, "intermediary 2", &intermediary2_children);
412  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
413  FlutterSemanticsNode2 leaf2 = CreateSemanticsNode(leaf2_id, "leaf 2");
414  FlutterSemanticsNode2 leaf3 = CreateSemanticsNode(leaf3_id, "leaf 3");
415 
416  bridge->AddFlutterSemanticsNodeUpdate(root);
417  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
418  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
419  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
420  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
421  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
422  bridge->CommitUpdates();
423  bridge->accessibility_events.clear();
424 
425  // Swap intermediary 1's and intermediary2's children.
426  int32_t new_intermediary1_children[] = {leaf2_id, leaf3_id};
427  intermediary1.child_count = 2;
428  intermediary1.children_in_traversal_order = new_intermediary1_children;
429 
430  int32_t new_intermediary2_children[] = {leaf1_id};
431  intermediary2.child_count = 1;
432  intermediary2.children_in_traversal_order = new_intermediary2_children;
433 
434  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
435  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
436  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
437  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
438  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
439  bridge->CommitUpdates();
440 
441  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
442  auto intermediary1_node =
443  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
444  auto intermediary2_node =
445  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
446  auto leaf1_node =
447  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
448  auto leaf2_node =
449  bridge->GetFlutterPlatformNodeDelegateFromID(leaf2_id).lock();
450  auto leaf3_node =
451  bridge->GetFlutterPlatformNodeDelegateFromID(leaf3_id).lock();
452 
453  EXPECT_EQ(root_node->GetChildCount(), 2);
454  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary1_id);
455  EXPECT_EQ(root_node->GetData().child_ids[1], intermediary2_id);
456  EXPECT_EQ(root_node->GetName(), "root");
457 
458  EXPECT_EQ(intermediary1_node->GetChildCount(), 2);
459  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf2_id);
460  EXPECT_EQ(intermediary1_node->GetData().child_ids[1], leaf3_id);
461  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
462 
463  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
464  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], leaf1_id);
465  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
466 
467  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
468  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
469 
470  EXPECT_EQ(leaf2_node->GetChildCount(), 0);
471  EXPECT_EQ(leaf2_node->GetName(), "leaf 2");
472 
473  EXPECT_EQ(leaf3_node->GetChildCount(), 0);
474  EXPECT_EQ(leaf3_node->GetName(), "leaf 3");
475 
476  // Intermediary 1 and intermediary 2 have new children.
477  // Leaf 1, 2, and 3 are all moved.
478  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
479  EXPECT_THAT(bridge->accessibility_events,
480  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
481  EXPECT_THAT(bridge->accessibility_events,
482  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(3));
483 }

References CreateSemanticsNode().

◆ TEST() [8/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanReparentNode   
)

Definition at line 329 of file accessibility_bridge_unittests.cc.

329  {
330  std::shared_ptr<TestAccessibilityBridge> bridge =
331  std::make_shared<TestAccessibilityBridge>();
332 
333  std::vector<int32_t> root_children{1};
334  std::vector<int32_t> child1_children{2};
335  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &root_children);
336  FlutterSemanticsNode2 child1 =
337  CreateSemanticsNode(1, "child 1", &child1_children);
338  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
339 
340  bridge->AddFlutterSemanticsNodeUpdate(root);
341  bridge->AddFlutterSemanticsNodeUpdate(child1);
342  bridge->AddFlutterSemanticsNodeUpdate(child2);
343  bridge->CommitUpdates();
344  bridge->accessibility_events.clear();
345 
346  // Reparent child2 from child1 to the root.
347  child1.child_count = 0;
348  child1.children_in_traversal_order = nullptr;
349 
350  int32_t new_root_children[] = {1, 2};
351  root.child_count = 2;
352  root.children_in_traversal_order = new_root_children;
353 
354  bridge->AddFlutterSemanticsNodeUpdate(root);
355  bridge->AddFlutterSemanticsNodeUpdate(child1);
356  bridge->AddFlutterSemanticsNodeUpdate(child2);
357  bridge->CommitUpdates();
358 
359  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
360  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
361  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
362 
363  EXPECT_EQ(root_node->GetChildCount(), 2);
364  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
365  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
366  EXPECT_EQ(root_node->GetName(), "root");
367 
368  EXPECT_EQ(child1_node->GetChildCount(), 0);
369  EXPECT_EQ(child1_node->GetName(), "child 1");
370 
371  EXPECT_EQ(child2_node->GetChildCount(), 0);
372  EXPECT_EQ(child2_node->GetName(), "child 2");
373 
374  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
375 
376  // Child2 is moved from child1 to root.
377  EXPECT_THAT(bridge->accessibility_events,
378  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
379  EXPECT_THAT(bridge->accessibility_events,
380  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
381 
382  // Child1 is no longer a parent. It loses its group role and disables its
383  // 'clip children' attribute.
384  EXPECT_THAT(
385  bridge->accessibility_events,
386  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
387  EXPECT_THAT(bridge->accessibility_events,
388  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
389 }

References CreateSemanticsNode().

◆ TEST() [9/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanReparentNodeWithChild   
)

Definition at line 486 of file accessibility_bridge_unittests.cc.

486  {
487  std::shared_ptr<TestAccessibilityBridge> bridge =
488  std::make_shared<TestAccessibilityBridge>();
489 
490  int32_t root_id = 0;
491  int32_t intermediary1_id = 1;
492  int32_t intermediary2_id = 2;
493  int32_t leaf1_id = 3;
494 
495  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
496  std::vector<int32_t> intermediary1_children{leaf1_id};
497  FlutterSemanticsNode2 root =
498  CreateSemanticsNode(root_id, "root", &root_children);
499  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
500  intermediary1_id, "intermediary 1", &intermediary1_children);
501  FlutterSemanticsNode2 intermediary2 =
502  CreateSemanticsNode(intermediary2_id, "intermediary 2");
503  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
504 
505  bridge->AddFlutterSemanticsNodeUpdate(root);
506  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
507  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
508  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
509  bridge->CommitUpdates();
510  bridge->accessibility_events.clear();
511 
512  // Move intermediary1 from root to intermediary 2.
513  int32_t new_root_children[] = {intermediary2_id};
514  root.child_count = 1;
515  root.children_in_traversal_order = new_root_children;
516 
517  int32_t new_intermediary2_children[] = {intermediary1_id};
518  intermediary2.child_count = 1;
519  intermediary2.children_in_traversal_order = new_intermediary2_children;
520 
521  bridge->AddFlutterSemanticsNodeUpdate(root);
522  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
523  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
524  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
525  bridge->CommitUpdates();
526 
527  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
528  auto intermediary1_node =
529  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
530  auto intermediary2_node =
531  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
532  auto leaf1_node =
533  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
534 
535  EXPECT_EQ(root_node->GetChildCount(), 1);
536  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary2_id);
537  EXPECT_EQ(root_node->GetName(), "root");
538 
539  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
540  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], intermediary1_id);
541  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
542 
543  EXPECT_EQ(intermediary1_node->GetChildCount(), 1);
544  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf1_id);
545  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
546 
547  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
548  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
549 
550  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
551 
552  EXPECT_THAT(bridge->accessibility_events,
553  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
554  EXPECT_THAT(bridge->accessibility_events,
555  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
556 
557  // Intermediary 2 becomes a parent node. It updates to group role and enables
558  // its 'clip children' attribute.
559  EXPECT_THAT(
560  bridge->accessibility_events,
561  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
562  EXPECT_THAT(bridge->accessibility_events,
563  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
564 }

References CreateSemanticsNode().

◆ TEST() [10/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanSetCheckboxChecked   
)

Definition at line 310 of file accessibility_bridge_unittests.cc.

310  {
311  std::shared_ptr<TestAccessibilityBridge> bridge =
312  std::make_shared<TestAccessibilityBridge>();
313  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
314  auto flags = FlutterSemanticsFlags{
315  .is_checked = FlutterCheckState::kFlutterCheckStateTrue,
316  };
317 
318  root.flags2 = &flags;
319  bridge->AddFlutterSemanticsNodeUpdate(root);
320  bridge->CommitUpdates();
321 
322  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
323  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
324  EXPECT_EQ(root_node->GetData().GetCheckedState(),
325  ax::mojom::CheckedState::kTrue);
326 }

References CreateSemanticsNode().

◆ TEST() [11/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
DoesNotAssignEditableRootToSelectableText   
)

Definition at line 250 of file accessibility_bridge_unittests.cc.

250  {
251  std::shared_ptr<TestAccessibilityBridge> bridge =
252  std::make_shared<TestAccessibilityBridge>();
253  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
254  auto flags = FlutterSemanticsFlags{
255  .is_text_field = true,
256  .is_read_only = true,
257  };
258  root.flags2 = &flags;
259 
260  bridge->AddFlutterSemanticsNodeUpdate(root);
261  bridge->CommitUpdates();
262 
263  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
264 
265  EXPECT_FALSE(root_node->GetData().GetBoolAttribute(
266  ax::mojom::BoolAttribute::kEditableRoot));
267 }

References CreateSemanticsNode().

◆ TEST() [12/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
LineBreakingObjectTest   
)

Definition at line 576 of file accessibility_bridge_unittests.cc.

576  {
577  std::shared_ptr<TestAccessibilityBridge> bridge =
578  std::make_shared<TestAccessibilityBridge>();
579 
580  const int32_t root_id = 0;
581 
582  FlutterSemanticsNode2 root = CreateSemanticsNode(root_id, "root", {});
583 
584  bridge->AddFlutterSemanticsNodeUpdate(root);
585  bridge->CommitUpdates();
586 
587  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
588  auto root_data = root_node->GetData();
589  EXPECT_TRUE(root_data.HasBoolAttribute(
590  ax::mojom::BoolAttribute::kIsLineBreakingObject));
591  EXPECT_TRUE(root_data.GetBoolAttribute(
592  ax::mojom::BoolAttribute::kIsLineBreakingObject));
593 }

References CreateSemanticsNode().

◆ TEST() [13/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
SliderHasSliderRole   
)

Definition at line 286 of file accessibility_bridge_unittests.cc.

286  {
287  std::shared_ptr<TestAccessibilityBridge> bridge =
288  std::make_shared<TestAccessibilityBridge>();
289  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
290  auto flags = FlutterSemanticsFlags{
291  .is_enabled = FlutterTristate::kFlutterTristateTrue,
292  .is_focused = FlutterTristate::kFlutterTristateFalse,
293  .is_slider = true,
294  };
295 
296  root.flags2 = &flags;
297 
298  bridge->AddFlutterSemanticsNodeUpdate(root);
299  bridge->CommitUpdates();
300 
301  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
302  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSlider);
303 }

References CreateSemanticsNode().

◆ TEST() [14/165]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
SwitchHasSwitchRole   
)

Definition at line 269 of file accessibility_bridge_unittests.cc.

269  {
270  std::shared_ptr<TestAccessibilityBridge> bridge =
271  std::make_shared<TestAccessibilityBridge>();
272  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
273  auto flags = FlutterSemanticsFlags{
274  .is_enabled = FlutterTristate::kFlutterTristateTrue,
275  .is_toggled = FlutterTristate::kFlutterTristateFalse,
276  };
277 
278  root.flags2 = &flags;
279  bridge->AddFlutterSemanticsNodeUpdate(root);
280  bridge->CommitUpdates();
281 
282  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
283  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
284 }

References CreateSemanticsNode().

◆ TEST() [15/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
DispatchAccessibilityAction   
)

Definition at line 279 of file accessibility_bridge_windows_unittests.cc.

279  {
280  auto engine = GetTestEngine();
281  FlutterWindowsViewSpy view{
282  engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
283  EngineModifier modifier{engine.get()};
284  modifier.SetImplicitView(&view);
285  view.OnUpdateSemanticsEnabled(true);
286 
287  auto bridge = view.accessibility_bridge().lock();
288  PopulateAXTree(bridge);
289 
290  FlutterSemanticsAction actual_action = kFlutterSemanticsActionTap;
291  modifier.embedder_api().SendSemanticsAction = MOCK_ENGINE_PROC(
292  SendSemanticsAction,
293  ([&actual_action](FLUTTER_API_SYMBOL(FlutterEngine) engine,
294  const FlutterSendSemanticsActionInfo* info) {
295  actual_action = info->action;
296  return kSuccess;
297  }));
298 
299  AccessibilityBridgeWindows delegate(&view);
300  delegate.DispatchAccessibilityAction(1, kFlutterSemanticsActionCopy, {});
301  EXPECT_EQ(actual_action, kFlutterSemanticsActionCopy);
302 }

References flutter::AccessibilityBridgeWindows::DispatchAccessibilityAction().

◆ TEST() [16/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
GetParent   
)

Definition at line 247 of file accessibility_bridge_windows_unittests.cc.

247  {
248  auto engine = GetTestEngine();
249  FlutterWindowsViewSpy view{
250  engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
251  EngineModifier modifier{engine.get()};
252  modifier.SetImplicitView(&view);
253  view.OnUpdateSemanticsEnabled(true);
254 
255  auto bridge = view.accessibility_bridge().lock();
256  PopulateAXTree(bridge);
257 
258  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
259  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
260  EXPECT_EQ(node0_delegate->GetNativeViewAccessible(),
261  node1_delegate->GetParent());
262 }

◆ TEST() [17/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
GetParentOnRootRetunsNullptr   
)

Definition at line 264 of file accessibility_bridge_windows_unittests.cc.

264  {
265  auto engine = GetTestEngine();
266  FlutterWindowsViewSpy view{
267  engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
268  EngineModifier modifier{engine.get()};
269  modifier.SetImplicitView(&view);
270  view.OnUpdateSemanticsEnabled(true);
271 
272  auto bridge = view.accessibility_bridge().lock();
273  PopulateAXTree(bridge);
274 
275  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
276  ASSERT_TRUE(node0_delegate->GetParent() == nullptr);
277 }

◆ TEST() [18/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityEventAlert   
)

Definition at line 304 of file accessibility_bridge_windows_unittests.cc.

304  {
305  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::ALERT,
306  ax::mojom::Event::kAlert);
307 }

◆ TEST() [19/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityEventChildrenChanged   
)

Definition at line 309 of file accessibility_bridge_windows_unittests.cc.

309  {
310  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::CHILDREN_CHANGED,
311  ax::mojom::Event::kChildrenChanged);
312 }

◆ TEST() [20/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityEventFocusChanged   
)

Definition at line 314 of file accessibility_bridge_windows_unittests.cc.

314  {
315  auto engine = GetTestEngine();
316  FlutterWindowsViewSpy view{
317  engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
318  EngineModifier modifier{engine.get()};
319  modifier.SetImplicitView(&view);
320  view.OnUpdateSemanticsEnabled(true);
321 
322  auto bridge = GetAccessibilityBridgeSpy(view);
323  PopulateAXTree(bridge);
324 
325  bridge->ResetRecords();
326  bridge->OnAccessibilityEvent({AXNodeFromID(bridge, 1),
327  {ui::AXEventGenerator::Event::FOCUS_CHANGED,
328  ax::mojom::EventFrom::kNone,
329  {}}});
330  ASSERT_EQ(bridge->dispatched_events().size(), 1);
331  EXPECT_EQ(bridge->dispatched_events()[0].event_type,
332  ax::mojom::Event::kFocus);
333 
334  ASSERT_EQ(bridge->focused_nodes().size(), 1);
335  EXPECT_EQ(bridge->focused_nodes()[0], 1);
336 }

◆ TEST() [21/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityEventIgnoredChanged   
)

Definition at line 338 of file accessibility_bridge_windows_unittests.cc.

338  {
339  // Static test nodes with no text, hint, or scrollability are ignored.
340  ExpectWinEventFromAXEvent(4, ui::AXEventGenerator::Event::IGNORED_CHANGED,
341  ax::mojom::Event::kHide);
342 }

◆ TEST() [22/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityHScrollPosChanged   
)

Definition at line 360 of file accessibility_bridge_windows_unittests.cc.

360  {
361  ExpectWinEventFromAXEvent(
362  1, ui::AXEventGenerator::Event::SCROLL_HORIZONTAL_POSITION_CHANGED,
363  ax::mojom::Event::kScrollPositionChanged);
364 }

◆ TEST() [23/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityImageAnnotationChanged   
)

Definition at line 344 of file accessibility_bridge_windows_unittests.cc.

344  {
345  ExpectWinEventFromAXEvent(
346  1, ui::AXEventGenerator::Event::IMAGE_ANNOTATION_CHANGED,
347  ax::mojom::Event::kTextChanged);
348 }

◆ TEST() [24/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityLiveRegionChanged   
)

Definition at line 350 of file accessibility_bridge_windows_unittests.cc.

350  {
351  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::LIVE_REGION_CHANGED,
352  ax::mojom::Event::kLiveRegionChanged);
353 }

◆ TEST() [25/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityNameChanged   
)

Definition at line 355 of file accessibility_bridge_windows_unittests.cc.

355  {
356  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::NAME_CHANGED,
357  ax::mojom::Event::kTextChanged);
358 }

◆ TEST() [26/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilitySelectedChanged   
)

Definition at line 372 of file accessibility_bridge_windows_unittests.cc.

372  {
373  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::SELECTED_CHANGED,
374  ax::mojom::Event::kValueChanged);
375 }

◆ TEST() [27/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilitySelectedChildrenChanged   
)

Definition at line 377 of file accessibility_bridge_windows_unittests.cc.

377  {
378  ExpectWinEventFromAXEvent(
379  2, ui::AXEventGenerator::Event::SELECTED_CHILDREN_CHANGED,
380  ax::mojom::Event::kSelectedChildrenChanged);
381 }

◆ TEST() [28/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityStateChanged   
)

Definition at line 393 of file accessibility_bridge_windows_unittests.cc.

393  {
394  ExpectWinEventFromAXEvent(
395  1, ui::AXEventGenerator::Event::WIN_IACCESSIBLE_STATE_CHANGED,
396  ax::mojom::Event::kStateChanged);
397 }

◆ TEST() [29/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilitySubtreeCreated   
)

Definition at line 383 of file accessibility_bridge_windows_unittests.cc.

383  {
384  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::SUBTREE_CREATED,
385  ax::mojom::Event::kShow);
386 }

◆ TEST() [30/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityValueChanged   
)

Definition at line 388 of file accessibility_bridge_windows_unittests.cc.

388  {
389  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::VALUE_CHANGED,
390  ax::mojom::Event::kValueChanged);
391 }

◆ TEST() [31/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnAccessibilityVScrollPosChanged   
)

Definition at line 366 of file accessibility_bridge_windows_unittests.cc.

366  {
367  ExpectWinEventFromAXEvent(
368  1, ui::AXEventGenerator::Event::SCROLL_VERTICAL_POSITION_CHANGED,
369  ax::mojom::Event::kScrollPositionChanged);
370 }

◆ TEST() [32/165]

flutter::testing::TEST ( AccessibilityBridgeWindows  ,
OnDocumentSelectionChanged   
)

Definition at line 399 of file accessibility_bridge_windows_unittests.cc.

399  {
400  ExpectWinEventFromAXEventOnFocusNode(
401  1, ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED,
402  ax::mojom::Event::kDocumentSelectionChanged, 2);
403 }

◆ TEST() [33/165]

flutter::testing::TEST ( DirectManipulationTest  ,
TestGesture   
)

Definition at line 141 of file direct_manipulation_unittests.cc.

141  {
142  MockIDirectManipulationContent content;
143  MockWindowBindingHandlerDelegate delegate;
144  MockIDirectManipulationViewport viewport;
145  const float scale = 1.5;
146  const float pan_x = 32.0;
147  const float pan_y = 16.0;
148  const int DISPLAY_WIDTH = 800;
149  const int DISPLAY_HEIGHT = 600;
150  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
151  owner->SetBindingHandlerDelegate(&delegate);
152  auto handler =
153  fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
154  int32_t device_id = (int32_t)reinterpret_cast<int64_t>(handler.get());
155  EXPECT_CALL(viewport, GetPrimaryContent(_, _))
156  .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
157  *out = &content;
158  return S_OK;
159  }))
160  .RetiresOnSaturation();
161  EXPECT_CALL(content, GetContentTransform(_, 6))
162  .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
163  transform[0] = 1.0f;
164  transform[4] = 0.0;
165  transform[5] = 0.0;
166  return S_OK;
167  }))
168  .RetiresOnSaturation();
169  EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
170  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
171  DIRECTMANIPULATION_RUNNING,
172  DIRECTMANIPULATION_READY);
173  EXPECT_CALL(content, GetContentTransform(_, 6))
174  .WillOnce(::testing::Invoke(
175  [scale, pan_x, pan_y](float* transform, DWORD size) {
176  transform[0] = scale;
177  transform[4] = pan_x;
178  transform[5] = pan_y;
179  return S_OK;
180  }));
181  EXPECT_CALL(delegate,
182  OnPointerPanZoomUpdate(device_id, pan_x, pan_y, scale, 0));
183  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
184  (IDirectManipulationContent*)&content);
185  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
186  EXPECT_CALL(viewport, GetViewportRect(_))
187  .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
188  rect->left = 0;
189  rect->top = 0;
190  rect->right = DISPLAY_WIDTH;
191  rect->bottom = DISPLAY_HEIGHT;
192  return S_OK;
193  }));
194  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
195  .WillOnce(::testing::Return(S_OK));
196  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
197  DIRECTMANIPULATION_INERTIA,
198  DIRECTMANIPULATION_RUNNING);
199  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
200  DIRECTMANIPULATION_READY,
201  DIRECTMANIPULATION_INERTIA);
202 }
content
union flutter::testing::@100::KeyboardChange::@0 content

References content.

◆ TEST() [34/165]

flutter::testing::TEST ( DirectManipulationTest  ,
TestGestureWithInitialData   
)

Definition at line 394 of file direct_manipulation_unittests.cc.

394  {
395  MockIDirectManipulationContent content;
396  MockWindowBindingHandlerDelegate delegate;
397  MockIDirectManipulationViewport viewport;
398  const float scale = 1.5;
399  const float pan_x = 32.0;
400  const float pan_y = 16.0;
401  const int DISPLAY_WIDTH = 800;
402  const int DISPLAY_HEIGHT = 600;
403  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
404  owner->SetBindingHandlerDelegate(&delegate);
405  auto handler =
406  fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
407  int32_t device_id = (int32_t)reinterpret_cast<int64_t>(handler.get());
408  EXPECT_CALL(viewport, GetPrimaryContent(_, _))
409  .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
410  *out = &content;
411  return S_OK;
412  }))
413  .RetiresOnSaturation();
414  EXPECT_CALL(content, GetContentTransform(_, 6))
415  .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
416  transform[0] = 2.0f;
417  transform[4] = 234.0;
418  transform[5] = 345.0;
419  return S_OK;
420  }))
421  .RetiresOnSaturation();
422  EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
423  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
424  DIRECTMANIPULATION_RUNNING,
425  DIRECTMANIPULATION_READY);
426  EXPECT_CALL(content, GetContentTransform(_, 6))
427  .WillOnce(::testing::Invoke(
428  [scale, pan_x, pan_y](float* transform, DWORD size) {
429  transform[0] = 2.0f * scale;
430  transform[4] = 234.0 + pan_x;
431  transform[5] = 345.0 + pan_y;
432  return S_OK;
433  }));
434  EXPECT_CALL(delegate,
435  OnPointerPanZoomUpdate(device_id, pan_x, pan_y, scale, 0));
436  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
437  (IDirectManipulationContent*)&content);
438  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
439  EXPECT_CALL(viewport, GetViewportRect(_))
440  .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
441  rect->left = 0;
442  rect->top = 0;
443  rect->right = DISPLAY_WIDTH;
444  rect->bottom = DISPLAY_HEIGHT;
445  return S_OK;
446  }));
447  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
448  .WillOnce(::testing::Return(S_OK));
449  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
450  DIRECTMANIPULATION_INERTIA,
451  DIRECTMANIPULATION_RUNNING);
452  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
453  DIRECTMANIPULATION_READY,
454  DIRECTMANIPULATION_INERTIA);
455 }

References content.

◆ TEST() [35/165]

flutter::testing::TEST ( DirectManipulationTest  ,
TestInertiaCamcelNotSentAtInertiaEnd   
)

Definition at line 340 of file direct_manipulation_unittests.cc.

340  {
341  MockIDirectManipulationContent content;
342  MockWindowBindingHandlerDelegate delegate;
343  MockIDirectManipulationViewport viewport;
344  const int DISPLAY_WIDTH = 800;
345  const int DISPLAY_HEIGHT = 600;
346  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
347  owner->SetBindingHandlerDelegate(&delegate);
348  auto handler =
349  fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
350  int32_t device_id = (int32_t)reinterpret_cast<int64_t>(handler.get());
351  // No need to mock the actual gesture, just start at the end.
352  EXPECT_CALL(viewport, GetViewportRect(_))
353  .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
354  rect->left = 0;
355  rect->top = 0;
356  rect->right = DISPLAY_WIDTH;
357  rect->bottom = DISPLAY_HEIGHT;
358  return S_OK;
359  }));
360  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
361  .WillOnce(::testing::Return(S_OK));
362  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
363  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
364  DIRECTMANIPULATION_INERTIA,
365  DIRECTMANIPULATION_RUNNING);
366  // Have no change in pan between events.
367  EXPECT_CALL(content, GetContentTransform(_, 6))
368  .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
369  transform[0] = 1;
370  transform[4] = 0;
371  transform[5] = 140;
372  return S_OK;
373  }));
374  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
375  (IDirectManipulationContent*)&content);
376  EXPECT_CALL(content, GetContentTransform(_, 6))
377  .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
378  transform[0] = 1;
379  transform[4] = 0;
380  transform[5] = 140;
381  return S_OK;
382  }));
383  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
384  (IDirectManipulationContent*)&content);
385  // OnScrollInertiaCancel should not be called.
386  EXPECT_CALL(delegate, OnScrollInertiaCancel(device_id)).Times(0);
387  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
388  DIRECTMANIPULATION_READY,
389  DIRECTMANIPULATION_INERTIA);
390 }

References content.

◆ TEST() [36/165]

flutter::testing::TEST ( DirectManipulationTest  ,
TestInertiaCancelSentForUserCancel   
)

Definition at line 287 of file direct_manipulation_unittests.cc.

287  {
288  MockIDirectManipulationContent content;
289  MockWindowBindingHandlerDelegate delegate;
290  MockIDirectManipulationViewport viewport;
291  const int DISPLAY_WIDTH = 800;
292  const int DISPLAY_HEIGHT = 600;
293  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
294  owner->SetBindingHandlerDelegate(&delegate);
295  auto handler =
296  fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
297  int32_t device_id = (int32_t)reinterpret_cast<int64_t>(handler.get());
298  // No need to mock the actual gesture, just start at the end.
299  EXPECT_CALL(viewport, GetViewportRect(_))
300  .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
301  rect->left = 0;
302  rect->top = 0;
303  rect->right = DISPLAY_WIDTH;
304  rect->bottom = DISPLAY_HEIGHT;
305  return S_OK;
306  }));
307  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
308  .WillOnce(::testing::Return(S_OK));
309  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
310  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
311  DIRECTMANIPULATION_INERTIA,
312  DIRECTMANIPULATION_RUNNING);
313  // Have pan_y change by 10 between inertia updates.
314  EXPECT_CALL(content, GetContentTransform(_, 6))
315  .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
316  transform[0] = 1;
317  transform[4] = 0;
318  transform[5] = 100;
319  return S_OK;
320  }));
321  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
322  (IDirectManipulationContent*)&content);
323  EXPECT_CALL(content, GetContentTransform(_, 6))
324  .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
325  transform[0] = 1;
326  transform[4] = 0;
327  transform[5] = 110;
328  return S_OK;
329  }));
330  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
331  (IDirectManipulationContent*)&content);
332  // This looks like an interruption in the middle of synthetic inertia because
333  // of user input.
334  EXPECT_CALL(delegate, OnScrollInertiaCancel(device_id));
335  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
336  DIRECTMANIPULATION_READY,
337  DIRECTMANIPULATION_INERTIA);
338 }

References content.

◆ TEST() [37/165]

flutter::testing::TEST ( DirectManipulationTest  ,
TestRounding   
)

Definition at line 205 of file direct_manipulation_unittests.cc.

205  {
206  MockIDirectManipulationContent content;
207  MockWindowBindingHandlerDelegate delegate;
208  MockIDirectManipulationViewport viewport;
209  const float scale = 1.5;
210  const int DISPLAY_WIDTH = 800;
211  const int DISPLAY_HEIGHT = 600;
212  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
213  owner->SetBindingHandlerDelegate(&delegate);
214  auto handler =
215  fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
216  int32_t device_id = (int32_t)reinterpret_cast<int64_t>(handler.get());
217  EXPECT_CALL(viewport, GetPrimaryContent(_, _))
218  .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
219  *out = &content;
220  return S_OK;
221  }))
222  .RetiresOnSaturation();
223  EXPECT_CALL(content, GetContentTransform(_, 6))
224  .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
225  transform[0] = 1.0f;
226  transform[4] = 0.0;
227  transform[5] = 0.0;
228  return S_OK;
229  }))
230  .RetiresOnSaturation();
231  EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
232  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
233  DIRECTMANIPULATION_RUNNING,
234  DIRECTMANIPULATION_READY);
235  EXPECT_CALL(content, GetContentTransform(_, 6))
236  .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
237  transform[0] = 1.5000001f;
238  transform[4] = 4.0;
239  transform[5] = 0.0;
240  return S_OK;
241  }))
242  .RetiresOnSaturation();
243  EXPECT_CALL(delegate,
244  OnPointerPanZoomUpdate(device_id, 4.0, 0, 1.5000001f, 0))
245  .Times(0);
246  EXPECT_CALL(delegate, OnPointerPanZoomUpdate(device_id, 4.0, 0, 1.5f, 0))
247  .Times(1)
248  .RetiresOnSaturation();
249  EXPECT_CALL(content, GetContentTransform(_, 6))
250  .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
251  transform[0] = 1.50000065f;
252  transform[4] = 2.0;
253  transform[5] = 0.0;
254  return S_OK;
255  }))
256  .RetiresOnSaturation();
257  EXPECT_CALL(delegate,
258  OnPointerPanZoomUpdate(device_id, 2.0, 0, 1.50000065f, 0))
259  .Times(0);
260  EXPECT_CALL(delegate,
261  OnPointerPanZoomUpdate(device_id, 2.0, 0, 1.50000047f, 0))
262  .Times(1)
263  .RetiresOnSaturation();
264  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
265  EXPECT_CALL(viewport, GetViewportRect(_))
266  .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
267  rect->left = 0;
268  rect->top = 0;
269  rect->right = DISPLAY_WIDTH;
270  rect->bottom = DISPLAY_HEIGHT;
271  return S_OK;
272  }));
273  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
274  .WillOnce(::testing::Return(S_OK));
275  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
276  (IDirectManipulationContent*)&content);
277  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
278  (IDirectManipulationContent*)&content);
279  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
280  DIRECTMANIPULATION_INERTIA,
281  DIRECTMANIPULATION_RUNNING);
282  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
283  DIRECTMANIPULATION_READY,
284  DIRECTMANIPULATION_INERTIA);
285 }

References content.

◆ TEST() [38/165]

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

Definition at line 13 of file dpi_utils_unittests.cc.

13  {
14  ASSERT_GT(GetDpiForHWND(nullptr), 0);
15  ASSERT_GT(GetDpiForMonitor(nullptr), 0);
16 };
flutter::GetDpiForHWND
UINT GetDpiForHWND(HWND hwnd)
Definition: dpi_utils.cc:128
flutter::GetDpiForMonitor
UINT GetDpiForMonitor(HMONITOR monitor)
Definition: dpi_utils.cc:132

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

◆ TEST() [39/165]

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

Definition at line 18 of file dpi_utils_unittests.cc.

18  {
19  const POINT target_point = {0, 0};
20  HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTOPRIMARY);
21  ASSERT_EQ(GetDpiForHWND(nullptr), GetDpiForMonitor(monitor));
22 };

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

◆ TEST() [40/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canCalculateBoundsCorrectly   
)

Definition at line 121 of file flutter_platform_node_delegate_unittests.cc.

121  {
122  std::shared_ptr<TestAccessibilityBridge> bridge =
123  std::make_shared<TestAccessibilityBridge>();
124  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
125  FlutterSemanticsNode2 root;
126  root.id = 0;
127  root.label = "root";
128  root.hint = "";
129  root.value = "";
130  root.increased_value = "";
131  root.decreased_value = "";
132  root.tooltip = "";
133  root.child_count = 1;
134  root.flags2 = &flags;
135  int32_t children[] = {1};
136  root.children_in_traversal_order = children;
137  root.custom_accessibility_actions_count = 0;
138  root.identifier = "";
139  root.rect = {0, 0, 100, 100}; // LTRB
140  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
141  bridge->AddFlutterSemanticsNodeUpdate(root);
142 
143  FlutterSemanticsNode2 child1;
144  child1.id = 1;
145  child1.label = "child 1";
146  child1.hint = "";
147  child1.value = "";
148  child1.increased_value = "";
149  child1.decreased_value = "";
150  child1.tooltip = "";
151  child1.child_count = 0;
152  child1.flags2 = &flags;
153  child1.custom_accessibility_actions_count = 0;
154  child1.identifier = "";
155  child1.rect = {0, 0, 50, 50}; // LTRB
156  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
157  bridge->AddFlutterSemanticsNodeUpdate(child1);
158 
159  bridge->CommitUpdates();
160  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
161  ui::AXOffscreenResult result;
162  gfx::Rect bounds =
163  child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
164  ui::AXClippingBehavior::kClipped, &result);
165  EXPECT_EQ(bounds.x(), 0);
166  EXPECT_EQ(bounds.y(), 0);
167  EXPECT_EQ(bounds.width(), 25);
168  EXPECT_EQ(bounds.height(), 25);
169  EXPECT_EQ(result, ui::AXOffscreenResult::kOnscreen);
170 }

◆ TEST() [41/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canCalculateOffScreenBoundsCorrectly   
)

Definition at line 172 of file flutter_platform_node_delegate_unittests.cc.

172  {
173  std::shared_ptr<TestAccessibilityBridge> bridge =
174  std::make_shared<TestAccessibilityBridge>();
175  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
176  FlutterSemanticsNode2 root;
177  root.id = 0;
178  root.label = "root";
179  root.hint = "";
180  root.value = "";
181  root.increased_value = "";
182  root.decreased_value = "";
183  root.tooltip = "";
184  root.child_count = 1;
185  root.flags2 = &flags;
186  int32_t children[] = {1};
187  root.children_in_traversal_order = children;
188  root.custom_accessibility_actions_count = 0;
189  root.identifier = "";
190  root.rect = {0, 0, 100, 100}; // LTRB
191  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
192  bridge->AddFlutterSemanticsNodeUpdate(root);
193 
194  FlutterSemanticsNode2 child1;
195  child1.id = 1;
196  child1.label = "child 1";
197  child1.hint = "";
198  child1.value = "";
199  child1.increased_value = "";
200  child1.decreased_value = "";
201  child1.tooltip = "";
202  child1.child_count = 0;
203  child1.flags2 = &flags;
204  child1.custom_accessibility_actions_count = 0;
205  child1.identifier = "";
206  child1.rect = {90, 90, 100, 100}; // LTRB
207  child1.transform = {2, 0, 0, 0, 2, 0, 0, 0, 1};
208  bridge->AddFlutterSemanticsNodeUpdate(child1);
209 
210  bridge->CommitUpdates();
211  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
212  ui::AXOffscreenResult result;
213  gfx::Rect bounds =
214  child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
215  ui::AXClippingBehavior::kUnclipped, &result);
216  EXPECT_EQ(bounds.x(), 180);
217  EXPECT_EQ(bounds.y(), 180);
218  EXPECT_EQ(bounds.width(), 20);
219  EXPECT_EQ(bounds.height(), 20);
220  EXPECT_EQ(result, ui::AXOffscreenResult::kOffscreen);
221 }

◆ TEST() [42/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canGetAXNode   
)

Definition at line 91 of file flutter_platform_node_delegate_unittests.cc.

91  {
92  // Set up a flutter accessibility node.
93  std::shared_ptr<TestAccessibilityBridge> bridge =
94  std::make_shared<TestAccessibilityBridge>();
95  FlutterSemanticsNode2 root;
96  root.id = 0;
97  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
98  flags.is_text_field = true;
99  root.flags2 = &flags;
100  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
101  root.actions = static_cast<FlutterSemanticsAction>(0);
102  root.text_selection_base = -1;
103  root.text_selection_extent = -1;
104  root.label = "root";
105  root.hint = "";
106  root.value = "";
107  root.increased_value = "";
108  root.decreased_value = "";
109  root.tooltip = "";
110  root.child_count = 0;
111  root.custom_accessibility_actions_count = 0;
112  root.identifier = "";
113  bridge->AddFlutterSemanticsNodeUpdate(root);
114 
115  bridge->CommitUpdates();
116 
117  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
118  EXPECT_EQ(accessibility->GetData().id, 0);
119 }

◆ TEST() [43/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canGetFromNodeID   
)

Definition at line 300 of file flutter_platform_node_delegate_unittests.cc.

300  {
301  std::shared_ptr<TestAccessibilityBridge> bridge =
302  std::make_shared<TestAccessibilityBridge>();
303  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
304  FlutterSemanticsNode2 root;
305  root.id = 0;
306  root.label = "root";
307  root.hint = "";
308  root.value = "";
309  root.increased_value = "";
310  root.decreased_value = "";
311  root.tooltip = "";
312  root.child_count = 1;
313  root.flags2 = &flags;
314  int32_t children[] = {1};
315  root.children_in_traversal_order = children;
316  root.custom_accessibility_actions_count = 0;
317  root.identifier = "";
318  bridge->AddFlutterSemanticsNodeUpdate(root);
319 
320  FlutterSemanticsNode2 child1;
321  child1.id = 1;
322  child1.label = "child 1";
323  child1.hint = "";
324  child1.value = "";
325  child1.increased_value = "";
326  child1.decreased_value = "";
327  child1.tooltip = "";
328  child1.child_count = 0;
329  child1.flags2 = &flags;
330  child1.custom_accessibility_actions_count = 0;
331  child1.identifier = "";
332  bridge->AddFlutterSemanticsNodeUpdate(child1);
333 
334  bridge->CommitUpdates();
335  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
336  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
337  auto node_by_id = root_node->GetFromNodeID(1);
338  EXPECT_EQ(child1_node->GetPlatformNode(), node_by_id);
339 }

◆ TEST() [44/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canPerfomActions   
)

Definition at line 43 of file flutter_platform_node_delegate_unittests.cc.

43  {
44  std::shared_ptr<TestAccessibilityBridge> bridge =
45  std::make_shared<TestAccessibilityBridge>();
46  FlutterSemanticsNode2 root;
47  root.id = 0;
48  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
49  flags.is_text_field = true;
50  root.flags2 = &flags;
51  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
52  root.actions = static_cast<FlutterSemanticsAction>(0);
53  root.text_selection_base = -1;
54  root.text_selection_extent = -1;
55  root.label = "root";
56  root.hint = "";
57  root.value = "";
58  root.increased_value = "";
59  root.decreased_value = "";
60  root.tooltip = "";
61  root.child_count = 0;
62  root.custom_accessibility_actions_count = 0;
63  root.identifier = "";
64  bridge->AddFlutterSemanticsNodeUpdate(root);
65 
66  bridge->CommitUpdates();
67 
68  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
69  // Performs an AXAction.
70  ui::AXActionData action_data;
71  action_data.action = ax::mojom::Action::kDoDefault;
72  accessibility->AccessibilityPerformAction(action_data);
73  EXPECT_EQ(bridge->performed_actions.size(), size_t{1});
74  EXPECT_EQ(bridge->performed_actions[0],
75  FlutterSemanticsAction::kFlutterSemanticsActionTap);
76 
77  action_data.action = ax::mojom::Action::kFocus;
78  accessibility->AccessibilityPerformAction(action_data);
79  EXPECT_EQ(bridge->performed_actions.size(), size_t{2});
80  EXPECT_EQ(
81  bridge->performed_actions[1],
82  FlutterSemanticsAction::kFlutterSemanticsActionDidGainAccessibilityFocus);
83 
84  action_data.action = ax::mojom::Action::kScrollToMakeVisible;
85  accessibility->AccessibilityPerformAction(action_data);
86  EXPECT_EQ(bridge->performed_actions.size(), size_t{3});
87  EXPECT_EQ(bridge->performed_actions[2],
88  FlutterSemanticsAction::kFlutterSemanticsActionShowOnScreen);
89 }

◆ TEST() [45/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canUseOwnerBridge   
)

Definition at line 223 of file flutter_platform_node_delegate_unittests.cc.

223  {
224  std::shared_ptr<TestAccessibilityBridge> bridge =
225  std::make_shared<TestAccessibilityBridge>();
226  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
227  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
228  root.label = "root";
229  root.hint = "";
230  root.value = "";
231  root.increased_value = "";
232  root.decreased_value = "";
233  root.tooltip = "";
234  root.heading_level = 0;
235  root.child_count = 1;
236  root.flags2 = &flags;
237  int32_t children[] = {1};
238  root.children_in_traversal_order = children;
239  root.custom_accessibility_actions_count = 0;
240  root.identifier = "";
241  root.rect = {0, 0, 100, 100}; // LTRB
242  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
243  bridge->AddFlutterSemanticsNodeUpdate(root);
244 
245  FlutterSemanticsNode2 child1{sizeof(FlutterSemanticsNode2), 1};
246  child1.label = "child 1";
247  child1.hint = "";
248  child1.value = "";
249  child1.increased_value = "";
250  child1.decreased_value = "";
251  child1.tooltip = "";
252  child1.heading_level = 0;
253  child1.child_count = 0;
254  child1.flags2 = &flags;
255  child1.custom_accessibility_actions_count = 0;
256  child1.identifier = "";
257  child1.rect = {0, 0, 50, 50}; // LTRB
258  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
259  bridge->AddFlutterSemanticsNodeUpdate(child1);
260 
261  bridge->CommitUpdates();
262  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
263  auto owner_bridge = child1_node->GetOwnerBridge().lock();
264 
265  bool result = false;
266  gfx::RectF bounds = owner_bridge->RelativeToGlobalBounds(
267  child1_node->GetAXNode(), result, true);
268  EXPECT_EQ(bounds.x(), 0);
269  EXPECT_EQ(bounds.y(), 0);
270  EXPECT_EQ(bounds.width(), 25);
271  EXPECT_EQ(bounds.height(), 25);
272  EXPECT_EQ(result, false);
273 }

◆ TEST() [46/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
NodeDelegateHasUniqueId   
)

Definition at line 15 of file flutter_platform_node_delegate_unittests.cc.

15  {
16  std::shared_ptr<TestAccessibilityBridge> bridge =
17  std::make_shared<TestAccessibilityBridge>();
18 
19  // Add node 0: root.
20  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
21  std::vector<int32_t> node0_children{1};
22  FlutterSemanticsFlags emptyFlags = FlutterSemanticsFlags{};
23  node0.child_count = node0_children.size();
24  node0.children_in_traversal_order = node0_children.data();
25  node0.children_in_hit_test_order = node0_children.data();
26  node0.flags2 = &emptyFlags;
27 
28  // Add node 1: text child of node 0.
29  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
30  node1.label = "prefecture";
31  node1.value = "Kyoto";
32  node1.flags2 = &emptyFlags;
33 
34  bridge->AddFlutterSemanticsNodeUpdate(node0);
35  bridge->AddFlutterSemanticsNodeUpdate(node1);
36  bridge->CommitUpdates();
37 
38  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
39  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
40  EXPECT_TRUE(node0_delegate->GetUniqueId() != node1_delegate->GetUniqueId());
41 }

◆ TEST() [47/165]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
selfIsLowestPlatformAncestor   
)

Definition at line 275 of file flutter_platform_node_delegate_unittests.cc.

275  {
276  std::shared_ptr<TestAccessibilityBridge> bridge =
277  std::make_shared<TestAccessibilityBridge>();
278  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
279  FlutterSemanticsNode2 root;
280  root.id = 0;
281  root.label = "root";
282  root.hint = "";
283  root.value = "";
284  root.increased_value = "";
285  root.decreased_value = "";
286  root.tooltip = "";
287  root.child_count = 0;
288  root.flags2 = &flags;
289  root.children_in_traversal_order = nullptr;
290  root.custom_accessibility_actions_count = 0;
291  root.identifier = "";
292  bridge->AddFlutterSemanticsNodeUpdate(root);
293 
294  bridge->CommitUpdates();
295  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
296  auto lowest_platform_ancestor = root_node->GetLowestPlatformAncestor();
297  EXPECT_EQ(root_node->GetNativeViewAccessible(), lowest_platform_ancestor);
298 }

◆ TEST() [48/165]

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

Definition at line 11 of file flutter_project_bundle_unittests.cc.

11  {
12  FlutterDesktopEngineProperties properties = {};
13  properties.assets_path = L"C:\\foo\\flutter_assets";
14  properties.icu_data_path = L"C:\\foo\\icudtl.dat";
15 
16  FlutterProjectBundle project(properties);
17 
18  EXPECT_TRUE(project.HasValidPaths());
19  EXPECT_EQ(project.assets_path().string(), "C:\\foo\\flutter_assets");
20  EXPECT_EQ(project.icu_path().string(), "C:\\foo\\icudtl.dat");
21 }

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

◆ TEST() [49/165]

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

Definition at line 23 of file flutter_project_bundle_unittests.cc.

23  {
24  FlutterDesktopEngineProperties properties = {};
25  properties.assets_path = L"foo\\flutter_assets";
26  properties.icu_data_path = L"foo\\icudtl.dat";
27 
28  FlutterProjectBundle project(properties);
29 
30  EXPECT_TRUE(project.HasValidPaths());
31  EXPECT_TRUE(project.assets_path().is_absolute());
32  EXPECT_EQ(project.assets_path().filename().string(), "flutter_assets");
33  EXPECT_TRUE(project.icu_path().is_absolute());
34  EXPECT_EQ(project.icu_path().filename().string(), "icudtl.dat");
35 }

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

◆ TEST() [50/165]

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

Definition at line 50 of file flutter_project_bundle_unittests.cc.

50  {
51  FlutterDesktopEngineProperties properties = {};
52  properties.assets_path = L"foo\\flutter_assets";
53  properties.icu_data_path = L"foo\\icudtl.dat";
54 
55  std::vector<const char*> test_arguments = {"arg1", "arg2"};
56  properties.dart_entrypoint_argc = test_arguments.size();
57  properties.dart_entrypoint_argv = test_arguments.data();
58 
59  FlutterProjectBundle project(properties);
60 
61  std::vector<std::string> retrieved_arguments =
62  project.dart_entrypoint_arguments();
63  EXPECT_EQ(retrieved_arguments.size(), 2U);
64  EXPECT_EQ(retrieved_arguments[0], "arg1");
65  EXPECT_EQ(retrieved_arguments[1], "arg2");
66 }

References FlutterDesktopEngineProperties::assets_path, FlutterDesktopEngineProperties::dart_entrypoint_argc, flutter::FlutterProjectBundle::dart_entrypoint_arguments(), FlutterDesktopEngineProperties::dart_entrypoint_argv, and FlutterDesktopEngineProperties::icu_data_path.

◆ TEST() [51/165]

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

Definition at line 69 of file flutter_project_bundle_unittests.cc.

69  {
70  FlutterDesktopEngineProperties properties = {};
71  properties.assets_path = L"foo\\flutter_assets";
72  properties.icu_data_path = L"foo\\icudtl.dat";
73 
74  _putenv_s("FLUTTER_ENGINE_SWITCHES", "2");
75  _putenv_s("FLUTTER_ENGINE_SWITCH_1", "abc");
76  _putenv_s("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
77 
78  FlutterProjectBundle project(properties);
79 
80  std::vector<std::string> switches = project.GetSwitches();
81  EXPECT_EQ(switches.size(), 2);
82  EXPECT_EQ(switches[0], "--abc");
83  EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
84 }

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

◆ TEST() [52/165]

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

Definition at line 37 of file flutter_project_bundle_unittests.cc.

37  {
38  FlutterDesktopEngineProperties properties = {};
39  properties.assets_path = L"foo\\flutter_assets";
40  properties.icu_data_path = L"foo\\icudtl.dat";
41 
42  // Clear the main environment variable, since test order is not guaranteed.
43  _putenv_s("FLUTTER_ENGINE_SWITCHES", "");
44 
45  FlutterProjectBundle project(properties);
46 
47  EXPECT_EQ(project.GetSwitches().size(), 0);
48 }

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

◆ TEST() [53/165]

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

Definition at line 67 of file flutter_windows_texture_registrar_unittests.cc.

67  {
68  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
69  auto gl = std::make_shared<egl::MockProcTable>();
70  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
71 
72  EXPECT_TRUE(true);
73 }

◆ TEST() [54/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
PopulateD3dTexture   
)

Definition at line 267 of file flutter_windows_texture_registrar_unittests.cc.

267  {
268  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
269  auto gl = std::make_shared<egl::MockProcTable>();
270  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
271 
272  UINT width = 100;
273  UINT height = 100;
274  auto d3d_texture = CreateD3dTexture(engine.get(), width, height);
275  EXPECT_TRUE(d3d_texture);
276 
277  bool release_callback_called = false;
278  FlutterDesktopGpuSurfaceDescriptor surface_descriptor = {};
279  surface_descriptor.struct_size = sizeof(FlutterDesktopGpuSurfaceDescriptor);
280  surface_descriptor.handle = d3d_texture.Get();
281  surface_descriptor.width = surface_descriptor.visible_width = width;
282  surface_descriptor.height = surface_descriptor.visible_height = height;
283  surface_descriptor.release_context = &release_callback_called;
284  surface_descriptor.release_callback = [](void* release_context) {
285  bool* called = reinterpret_cast<bool*>(release_context);
286  *called = true;
287  };
288 
289  FlutterDesktopTextureInfo texture_info = {};
290  texture_info.type = kFlutterDesktopGpuSurfaceTexture;
291  texture_info.gpu_surface_config.struct_size =
292  sizeof(FlutterDesktopGpuSurfaceTextureConfig);
293  texture_info.gpu_surface_config.type =
294  kFlutterDesktopGpuSurfaceTypeD3d11Texture2D;
295  texture_info.gpu_surface_config.user_data = &surface_descriptor;
296  texture_info.gpu_surface_config.callback =
297  [](size_t width, size_t height,
298  void* user_data) -> const FlutterDesktopGpuSurfaceDescriptor* {
299  return reinterpret_cast<const FlutterDesktopGpuSurfaceDescriptor*>(
300  user_data);
301  };
302 
303  FlutterOpenGLTexture flutter_texture = {};
304  auto texture_id = registrar.RegisterTexture(&texture_info);
305  EXPECT_NE(texture_id, -1);
306 
307  EXPECT_CALL(*gl.get(), GenTextures(1, _))
308  .Times(1)
309  .WillOnce([](GLsizei n, GLuint* textures) { textures[0] = 1; });
310  EXPECT_CALL(*gl.get(), BindTexture).Times(1);
311  EXPECT_CALL(*gl.get(), TexParameteri).Times(AtLeast(1));
312  EXPECT_CALL(*gl.get(), DeleteTextures(1, _)).Times(1);
313 
314  auto result =
315  registrar.PopulateTexture(texture_id, 640, 480, &flutter_texture);
316  EXPECT_TRUE(result);
317  EXPECT_EQ(flutter_texture.width, width);
318  EXPECT_EQ(flutter_texture.height, height);
319  EXPECT_EQ(flutter_texture.target, GL_TEXTURE_2D);
320  EXPECT_TRUE(release_callback_called);
321 }
texture_id
uint32_t texture_id
Definition: compositor_opengl.cc:20
kFlutterDesktopGpuSurfaceTypeD3d11Texture2D
@ kFlutterDesktopGpuSurfaceTypeD3d11Texture2D
Definition: flutter_texture_registrar.h:40
kFlutterDesktopGpuSurfaceTexture
@ kFlutterDesktopGpuSurfaceTexture
Definition: flutter_texture_registrar.h:28
user_data
void * user_data
Definition: flutter_windows_view_unittests.cc:53
FlutterDesktopGpuSurfaceDescriptor::release_callback
void(* release_callback)(void *release_context)
Definition: flutter_texture_registrar.h:100
FlutterDesktopGpuSurfaceTextureConfig::callback
FlutterDesktopGpuSurfaceTextureCallback callback
Definition: flutter_texture_registrar.h:146
FlutterDesktopTextureInfo::gpu_surface_config
FlutterDesktopGpuSurfaceTextureConfig gpu_surface_config
Definition: flutter_texture_registrar.h:155
FlutterDesktopTextureInfo::type
FlutterDesktopTextureType type
Definition: flutter_texture_registrar.h:152

References FlutterDesktopGpuSurfaceTextureConfig::callback, FlutterDesktopTextureInfo::gpu_surface_config, FlutterDesktopGpuSurfaceDescriptor::handle, FlutterDesktopGpuSurfaceDescriptor::height, kFlutterDesktopGpuSurfaceTexture, kFlutterDesktopGpuSurfaceTypeD3d11Texture2D, flutter::FlutterWindowsTextureRegistrar::PopulateTexture(), flutter::FlutterWindowsTextureRegistrar::RegisterTexture(), FlutterDesktopGpuSurfaceDescriptor::release_callback, FlutterDesktopGpuSurfaceDescriptor::release_context, FlutterDesktopGpuSurfaceDescriptor::struct_size, FlutterDesktopGpuSurfaceTextureConfig::struct_size, texture_id, FlutterDesktopGpuSurfaceTextureConfig::type, FlutterDesktopTextureInfo::type, FlutterDesktopGpuSurfaceTextureConfig::user_data, user_data, FlutterDesktopGpuSurfaceDescriptor::visible_height, FlutterDesktopGpuSurfaceDescriptor::visible_width, and FlutterDesktopGpuSurfaceDescriptor::width.

◆ TEST() [55/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
PopulateD3dTextureWithHandle   
)

Definition at line 205 of file flutter_windows_texture_registrar_unittests.cc.

205  {
206  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
207  auto gl = std::make_shared<egl::MockProcTable>();
208  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
209 
210  UINT width = 100;
211  UINT height = 100;
212  auto d3d_texture = CreateD3dTexture(engine.get(), width, height);
213  EXPECT_TRUE(d3d_texture);
214 
215  ComPtr<IDXGIResource> shared_resource;
216  EXPECT_TRUE(SUCCEEDED(d3d_texture.As(&shared_resource)));
217 
218  HANDLE shared_handle;
219  EXPECT_TRUE(SUCCEEDED(shared_resource->GetSharedHandle(&shared_handle)));
220 
221  bool release_callback_called = false;
222  FlutterDesktopGpuSurfaceDescriptor surface_descriptor = {};
223  surface_descriptor.struct_size = sizeof(FlutterDesktopGpuSurfaceDescriptor);
224  surface_descriptor.handle = shared_handle;
225  surface_descriptor.width = surface_descriptor.visible_width = width;
226  surface_descriptor.height = surface_descriptor.visible_height = height;
227  surface_descriptor.release_context = &release_callback_called;
228  surface_descriptor.release_callback = [](void* release_context) {
229  bool* called = reinterpret_cast<bool*>(release_context);
230  *called = true;
231  };
232 
233  FlutterDesktopTextureInfo texture_info = {};
234  texture_info.type = kFlutterDesktopGpuSurfaceTexture;
235  texture_info.gpu_surface_config.struct_size =
236  sizeof(FlutterDesktopGpuSurfaceTextureConfig);
237  texture_info.gpu_surface_config.type =
238  kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle;
239  texture_info.gpu_surface_config.user_data = &surface_descriptor;
240  texture_info.gpu_surface_config.callback =
241  [](size_t width, size_t height,
242  void* user_data) -> const FlutterDesktopGpuSurfaceDescriptor* {
243  return reinterpret_cast<const FlutterDesktopGpuSurfaceDescriptor*>(
244  user_data);
245  };
246 
247  FlutterOpenGLTexture flutter_texture = {};
248  auto texture_id = registrar.RegisterTexture(&texture_info);
249  EXPECT_NE(texture_id, -1);
250 
251  EXPECT_CALL(*gl.get(), GenTextures(1, _))
252  .Times(1)
253  .WillOnce([](GLsizei n, GLuint* textures) { textures[0] = 1; });
254  EXPECT_CALL(*gl.get(), BindTexture).Times(1);
255  EXPECT_CALL(*gl.get(), TexParameteri).Times(AtLeast(1));
256  EXPECT_CALL(*gl.get(), DeleteTextures(1, _)).Times(1);
257 
258  auto result =
259  registrar.PopulateTexture(texture_id, 640, 480, &flutter_texture);
260  EXPECT_TRUE(result);
261  EXPECT_EQ(flutter_texture.width, width);
262  EXPECT_EQ(flutter_texture.height, height);
263  EXPECT_EQ(flutter_texture.target, GL_TEXTURE_2D);
264  EXPECT_TRUE(release_callback_called);
265 }
kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle
@ kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle
Definition: flutter_texture_registrar.h:38

References FlutterDesktopGpuSurfaceTextureConfig::callback, FlutterDesktopTextureInfo::gpu_surface_config, FlutterDesktopGpuSurfaceDescriptor::handle, FlutterDesktopGpuSurfaceDescriptor::height, kFlutterDesktopGpuSurfaceTexture, kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle, flutter::FlutterWindowsTextureRegistrar::PopulateTexture(), flutter::FlutterWindowsTextureRegistrar::RegisterTexture(), FlutterDesktopGpuSurfaceDescriptor::release_callback, FlutterDesktopGpuSurfaceDescriptor::release_context, FlutterDesktopGpuSurfaceDescriptor::struct_size, FlutterDesktopGpuSurfaceTextureConfig::struct_size, texture_id, FlutterDesktopGpuSurfaceTextureConfig::type, FlutterDesktopTextureInfo::type, FlutterDesktopGpuSurfaceTextureConfig::user_data, user_data, FlutterDesktopGpuSurfaceDescriptor::visible_height, FlutterDesktopGpuSurfaceDescriptor::visible_width, and FlutterDesktopGpuSurfaceDescriptor::width.

◆ TEST() [56/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
PopulateInvalidTexture   
)

Definition at line 323 of file flutter_windows_texture_registrar_unittests.cc.

323  {
324  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
325  auto gl = std::make_shared<egl::MockProcTable>();
326 
327  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
328 
329  auto result = registrar.PopulateTexture(1, 640, 480, nullptr);
330  EXPECT_FALSE(result);
331 }

References flutter::FlutterWindowsTextureRegistrar::PopulateTexture().

◆ TEST() [57/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
PopulatePixelBufferTexture   
)

Definition at line 154 of file flutter_windows_texture_registrar_unittests.cc.

154  {
155  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
156  auto gl = std::make_shared<egl::MockProcTable>();
157 
158  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
159 
160  bool release_callback_called = false;
161  size_t width = 100;
162  size_t height = 100;
163  std::unique_ptr<uint8_t[]> pixels =
164  std::make_unique<uint8_t[]>(width * height * 4);
165  FlutterDesktopPixelBuffer pixel_buffer = {};
166  pixel_buffer.width = width;
167  pixel_buffer.height = height;
168  pixel_buffer.buffer = pixels.get();
169  pixel_buffer.release_context = &release_callback_called;
170  pixel_buffer.release_callback = [](void* release_context) {
171  bool* called = reinterpret_cast<bool*>(release_context);
172  *called = true;
173  };
174 
175  FlutterDesktopTextureInfo texture_info = {};
176  texture_info.type = kFlutterDesktopPixelBufferTexture;
177  texture_info.pixel_buffer_config.user_data = &pixel_buffer;
178  texture_info.pixel_buffer_config.callback =
179  [](size_t width, size_t height,
180  void* user_data) -> const FlutterDesktopPixelBuffer* {
181  return reinterpret_cast<const FlutterDesktopPixelBuffer*>(user_data);
182  };
183 
184  FlutterOpenGLTexture flutter_texture = {};
185  auto texture_id = registrar.RegisterTexture(&texture_info);
186  EXPECT_NE(texture_id, -1);
187 
188  EXPECT_CALL(*gl.get(), GenTextures(1, _))
189  .Times(1)
190  .WillOnce([](GLsizei n, GLuint* textures) { textures[0] = 1; });
191  EXPECT_CALL(*gl.get(), BindTexture).Times(1);
192  EXPECT_CALL(*gl.get(), TexParameteri).Times(AtLeast(1));
193  EXPECT_CALL(*gl.get(), TexImage2D).Times(1);
194  EXPECT_CALL(*gl.get(), DeleteTextures(1, _)).Times(1);
195 
196  auto result =
197  registrar.PopulateTexture(texture_id, 640, 480, &flutter_texture);
198  EXPECT_TRUE(result);
199  EXPECT_EQ(flutter_texture.width, width);
200  EXPECT_EQ(flutter_texture.height, height);
201  EXPECT_EQ(flutter_texture.target, GL_TEXTURE_2D);
202  EXPECT_TRUE(release_callback_called);
203 }
kFlutterDesktopPixelBufferTexture
@ kFlutterDesktopPixelBufferTexture
Definition: flutter_texture_registrar.h:26
FlutterDesktopPixelBuffer::release_callback
void(* release_callback)(void *release_context)
Definition: flutter_texture_registrar.h:64
FlutterDesktopPixelBufferTextureConfig::callback
FlutterDesktopPixelBufferTextureCallback callback
Definition: flutter_texture_registrar.h:132
FlutterDesktopTextureInfo::pixel_buffer_config
FlutterDesktopPixelBufferTextureConfig pixel_buffer_config
Definition: flutter_texture_registrar.h:154

References FlutterDesktopPixelBuffer::buffer, FlutterDesktopPixelBufferTextureConfig::callback, FlutterDesktopPixelBuffer::height, kFlutterDesktopPixelBufferTexture, FlutterDesktopTextureInfo::pixel_buffer_config, flutter::FlutterWindowsTextureRegistrar::PopulateTexture(), flutter::FlutterWindowsTextureRegistrar::RegisterTexture(), FlutterDesktopPixelBuffer::release_callback, FlutterDesktopPixelBuffer::release_context, texture_id, FlutterDesktopTextureInfo::type, FlutterDesktopPixelBufferTextureConfig::user_data, user_data, and FlutterDesktopPixelBuffer::width.

◆ TEST() [58/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
RegisterUnknownTextureType   
)

Definition at line 140 of file flutter_windows_texture_registrar_unittests.cc.

140  {
141  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
142  auto gl = std::make_shared<egl::MockProcTable>();
143 
144  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
145 
146  FlutterDesktopTextureInfo texture_info = {};
147  texture_info.type = static_cast<FlutterDesktopTextureType>(1234);
148 
149  auto texture_id = registrar.RegisterTexture(&texture_info);
150 
151  EXPECT_EQ(texture_id, -1);
152 }
FlutterDesktopTextureType
FlutterDesktopTextureType
Definition: flutter_texture_registrar.h:24

References flutter::FlutterWindowsTextureRegistrar::RegisterTexture(), texture_id, and FlutterDesktopTextureInfo::type.

◆ TEST() [59/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
RegisterUnregisterTexture   
)

Definition at line 75 of file flutter_windows_texture_registrar_unittests.cc.

75  {
76  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
77  EngineModifier modifier(engine.get());
78  auto gl = std::make_shared<egl::MockProcTable>();
79 
80  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
81 
82  FlutterDesktopTextureInfo texture_info = {};
83  texture_info.type = kFlutterDesktopPixelBufferTexture;
84  texture_info.pixel_buffer_config.callback =
85  [](size_t width, size_t height,
86  void* user_data) -> const FlutterDesktopPixelBuffer* {
87  return nullptr;
88  };
89 
90  int64_t registered_texture_id = 0;
91  bool register_called = false;
92  modifier.embedder_api().RegisterExternalTexture = MOCK_ENGINE_PROC(
93  RegisterExternalTexture, ([&register_called, &registered_texture_id](
94  auto engine, auto texture_id) {
95  register_called = true;
96  registered_texture_id = texture_id;
97  return kSuccess;
98  }));
99 
100  bool unregister_called = false;
101  modifier.embedder_api().UnregisterExternalTexture = MOCK_ENGINE_PROC(
102  UnregisterExternalTexture, ([&unregister_called, &registered_texture_id](
103  auto engine, auto texture_id) {
104  unregister_called = true;
105  EXPECT_EQ(registered_texture_id, texture_id);
106  return kSuccess;
107  }));
108 
109  bool mark_frame_available_called = false;
110  modifier.embedder_api().MarkExternalTextureFrameAvailable =
111  MOCK_ENGINE_PROC(MarkExternalTextureFrameAvailable,
112  ([&mark_frame_available_called, &registered_texture_id](
113  auto engine, auto texture_id) {
114  mark_frame_available_called = true;
115  EXPECT_EQ(registered_texture_id, texture_id);
116  return kSuccess;
117  }));
118 
119  modifier.embedder_api().PostRenderThreadTask =
120  MOCK_ENGINE_PROC(PostRenderThreadTask,
121  [](auto engine, auto callback, void* callback_data) {
122  callback(callback_data);
123  return kSuccess;
124  });
125 
126  auto texture_id = registrar.RegisterTexture(&texture_info);
127  EXPECT_TRUE(register_called);
128  EXPECT_NE(texture_id, -1);
129  EXPECT_EQ(texture_id, registered_texture_id);
130 
131  EXPECT_TRUE(registrar.MarkTextureFrameAvailable(texture_id));
132  EXPECT_TRUE(mark_frame_available_called);
133 
134  fml::AutoResetWaitableEvent latch;
135  registrar.UnregisterTexture(texture_id, [&]() { latch.Signal(); });
136  latch.Wait();
137  ASSERT_TRUE(unregister_called);
138 }
callback
FlutterDesktopBinaryReply callback
Definition: flutter_windows_view_unittests.cc:52

References FlutterDesktopPixelBufferTextureConfig::callback, callback, kFlutterDesktopPixelBufferTexture, flutter::FlutterWindowsTextureRegistrar::MarkTextureFrameAvailable(), FlutterDesktopTextureInfo::pixel_buffer_config, flutter::FlutterWindowsTextureRegistrar::RegisterTexture(), texture_id, FlutterDesktopTextureInfo::type, flutter::FlutterWindowsTextureRegistrar::UnregisterTexture(), and user_data.

◆ TEST() [60/165]

flutter::testing::TEST ( FlutterWindowsTextureRegistrarTest  ,
UnregisterTextureWithEngineDownInvokesCallback   
)

Definition at line 333 of file flutter_windows_texture_registrar_unittests.cc.

334  {
335  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
336  auto gl = std::make_shared<egl::MockProcTable>();
337 
338  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
339 
340  fml::AutoResetWaitableEvent latch;
341  registrar.UnregisterTexture(1234, [&]() { latch.Signal(); });
342  latch.Wait();
343 }

References flutter::FlutterWindowsTextureRegistrar::UnregisterTexture().

◆ TEST() [61/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
AccessibilityHitTesting   
)

Definition at line 803 of file flutter_windows_view_unittests.cc.

803  {
804  constexpr FlutterTransformation kIdentityTransform = {1, 0, 0, //
805  0, 1, 0, //
806  0, 0, 1};
807 
808  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
809  EngineModifier modifier(engine.get());
810  modifier.embedder_api().UpdateSemanticsEnabled =
811  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
812  return kSuccess;
813  };
814 
815  std::unique_ptr<FlutterWindowsView> view =
816  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
817  /*is_sized_to_content=*/false, BoxConstraints());
818 
819  // Enable semantics to instantiate accessibility bridge.
820  view->OnUpdateSemanticsEnabled(true);
821 
822  auto bridge = view->accessibility_bridge().lock();
823  ASSERT_TRUE(bridge);
824 
825  // Add root node at origin. Size 500x500.
826  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
827  auto empty_flags = FlutterSemanticsFlags{};
828  std::vector<int32_t> node0_children{1, 2};
829  node0.rect = {0, 0, 500, 500};
830  node0.transform = kIdentityTransform;
831  node0.child_count = node0_children.size();
832  node0.children_in_traversal_order = node0_children.data();
833  node0.children_in_hit_test_order = node0_children.data();
834  node0.flags2 = &empty_flags;
835 
836  // Add node 1 located at 0,0 relative to node 0. Size 250x500.
837  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
838  node1.rect = {0, 0, 250, 500};
839  node1.transform = kIdentityTransform;
840  node1.label = "prefecture";
841  node1.value = "Kyoto";
842  node1.flags2 = &empty_flags;
843 
844  // Add node 2 located at 250,0 relative to node 0. Size 250x500.
845  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
846  std::vector<int32_t> node2_children{3};
847  node2.rect = {0, 0, 250, 500};
848  node2.transform = {1, 0, 250, 0, 1, 0, 0, 0, 1};
849  node2.child_count = node2_children.size();
850  node2.children_in_traversal_order = node2_children.data();
851  node2.children_in_hit_test_order = node2_children.data();
852  node2.flags2 = &empty_flags;
853 
854  // Add node 3 located at 0,250 relative to node 2. Size 250, 250.
855  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
856  node3.rect = {0, 0, 250, 250};
857  node3.transform = {1, 0, 0, 0, 1, 250, 0, 0, 1};
858  node3.label = "city";
859  node3.value = "Uji";
860  node3.flags2 = &empty_flags;
861 
862  bridge->AddFlutterSemanticsNodeUpdate(node0);
863  bridge->AddFlutterSemanticsNodeUpdate(node1);
864  bridge->AddFlutterSemanticsNodeUpdate(node2);
865  bridge->AddFlutterSemanticsNodeUpdate(node3);
866  bridge->CommitUpdates();
867 
868  // Look up the root windows node delegate.
869  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
870  ASSERT_TRUE(node0_delegate);
871  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
872  ASSERT_TRUE(node1_delegate);
873  auto node2_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
874  ASSERT_TRUE(node2_delegate);
875  auto node3_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(3).lock();
876  ASSERT_TRUE(node3_delegate);
877 
878  // Get the native IAccessible root object.
879  IAccessible* node0_accessible = node0_delegate->GetNativeViewAccessible();
880  ASSERT_TRUE(node0_accessible != nullptr);
881 
882  // Perform a hit test that should hit node 1.
883  VARIANT varchild{};
884  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(150, 150, &varchild)));
885  EXPECT_EQ(varchild.vt, VT_DISPATCH);
886  EXPECT_EQ(varchild.pdispVal, node1_delegate->GetNativeViewAccessible());
887 
888  // Perform a hit test that should hit node 2.
889  varchild = {};
890  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 150, &varchild)));
891  EXPECT_EQ(varchild.vt, VT_DISPATCH);
892  EXPECT_EQ(varchild.pdispVal, node2_delegate->GetNativeViewAccessible());
893 
894  // Perform a hit test that should hit node 3.
895  varchild = {};
896  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 450, &varchild)));
897  EXPECT_EQ(varchild.vt, VT_DISPATCH);
898  EXPECT_EQ(varchild.pdispVal, node3_delegate->GetNativeViewAccessible());
899 }

◆ TEST() [62/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
AddSemanticsNodeUpdate   
)

Definition at line 370 of file flutter_windows_view_unittests.cc.

370  {
371  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
372  EngineModifier modifier(engine.get());
373  modifier.embedder_api().UpdateSemanticsEnabled =
374  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
375  return kSuccess;
376  };
377 
378  auto window_binding_handler =
379  std::make_unique<NiceMock<MockWindowBindingHandler>>();
380  std::unique_ptr<FlutterWindowsView> view =
381  engine->CreateView(std::move(window_binding_handler),
382  /*is_sized_to_content=*/false, BoxConstraints());
383 
384  // Enable semantics to instantiate accessibility bridge.
385  view->OnUpdateSemanticsEnabled(true);
386 
387  auto bridge = view->accessibility_bridge().lock();
388  ASSERT_TRUE(bridge);
389 
390  // Add root node.
391  FlutterSemanticsNode2 node{sizeof(FlutterSemanticsNode2), 0};
392  node.label = "name";
393  node.value = "value";
394  node.platform_view_id = -1;
395  auto flags = FlutterSemanticsFlags{};
396  node.flags2 = &flags;
397  bridge->AddFlutterSemanticsNodeUpdate(node);
398  bridge->CommitUpdates();
399 
400  // Look up the root windows node delegate.
401  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
402  ASSERT_TRUE(node_delegate);
403  EXPECT_EQ(node_delegate->GetChildCount(), 0);
404 
405  // Get the native IAccessible object.
406  IAccessible* native_view = node_delegate->GetNativeViewAccessible();
407  ASSERT_TRUE(native_view != nullptr);
408 
409  // Property lookups will be made against this node itself.
410  VARIANT varchild{};
411  varchild.vt = VT_I4;
412  varchild.lVal = CHILDID_SELF;
413 
414  // Verify node name matches our label.
415  BSTR bname = nullptr;
416  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
417  std::string name(_com_util::ConvertBSTRToString(bname));
418  EXPECT_EQ(name, "name");
419 
420  // Verify node value matches.
421  BSTR bvalue = nullptr;
422  ASSERT_EQ(native_view->get_accValue(varchild, &bvalue), S_OK);
423  std::string value(_com_util::ConvertBSTRToString(bvalue));
424  EXPECT_EQ(value, "value");
425 
426  // Verify node type is static text.
427  VARIANT varrole{};
428  varrole.vt = VT_I4;
429  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
430  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
431 
432  // Get the IRawElementProviderFragment object.
433  IRawElementProviderSimple* uia_view;
434  native_view->QueryInterface(IID_PPV_ARGS(&uia_view));
435  ASSERT_TRUE(uia_view != nullptr);
436 
437  // Verify name property matches our label.
438  VARIANT varname{};
439  ASSERT_EQ(uia_view->GetPropertyValue(UIA_NamePropertyId, &varname), S_OK);
440  EXPECT_EQ(varname.vt, VT_BSTR);
441  name = _com_util::ConvertBSTRToString(varname.bstrVal);
442  EXPECT_EQ(name, "name");
443 
444  // Verify value property matches our label.
445  VARIANT varvalue{};
446  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ValueValuePropertyId, &varvalue),
447  S_OK);
448  EXPECT_EQ(varvalue.vt, VT_BSTR);
449  value = _com_util::ConvertBSTRToString(varvalue.bstrVal);
450  EXPECT_EQ(value, "value");
451 
452  // Verify node control type is text.
453  varrole = {};
454  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
455  S_OK);
456  EXPECT_EQ(varrole.vt, VT_I4);
457  EXPECT_EQ(varrole.lVal, UIA_TextControlTypeId);
458 }
node_delegate
std::shared_ptr< FlutterPlatformNodeDelegateWindows > node_delegate
Definition: accessibility_bridge_windows_unittests.cc:33

References node_delegate.

◆ TEST() [63/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
AddSemanticsNodeUpdateWithChildren   
)

Definition at line 472 of file flutter_windows_view_unittests.cc.

472  {
473  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
474  EngineModifier modifier(engine.get());
475  modifier.embedder_api().UpdateSemanticsEnabled =
476  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
477  return kSuccess;
478  };
479 
480  std::unique_ptr<FlutterWindowsView> view =
481  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
482  /*is_sized_to_content=*/false, BoxConstraints());
483 
484  // Enable semantics to instantiate accessibility bridge.
485  view->OnUpdateSemanticsEnabled(true);
486 
487  auto bridge = view->accessibility_bridge().lock();
488  ASSERT_TRUE(bridge);
489 
490  // Add root node.
491  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
492  std::vector<int32_t> node0_children{1, 2};
493  node0.child_count = node0_children.size();
494  node0.children_in_traversal_order = node0_children.data();
495  node0.children_in_hit_test_order = node0_children.data();
496  auto empty_flags = FlutterSemanticsFlags{};
497  node0.flags2 = &empty_flags;
498 
499  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
500  node1.label = "prefecture";
501  node1.value = "Kyoto";
502  node1.flags2 = &empty_flags;
503  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
504  std::vector<int32_t> node2_children{3};
505  node2.child_count = node2_children.size();
506  node2.children_in_traversal_order = node2_children.data();
507  node2.children_in_hit_test_order = node2_children.data();
508  node2.flags2 = &empty_flags;
509  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
510  node3.label = "city";
511  node3.value = "Uji";
512  node3.flags2 = &empty_flags;
513 
514  bridge->AddFlutterSemanticsNodeUpdate(node0);
515  bridge->AddFlutterSemanticsNodeUpdate(node1);
516  bridge->AddFlutterSemanticsNodeUpdate(node2);
517  bridge->AddFlutterSemanticsNodeUpdate(node3);
518  bridge->CommitUpdates();
519 
520  // Look up the root windows node delegate.
521  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
522  ASSERT_TRUE(node_delegate);
523  EXPECT_EQ(node_delegate->GetChildCount(), 2);
524 
525  // Get the native IAccessible object.
526  IAccessible* node0_accessible = node_delegate->GetNativeViewAccessible();
527  ASSERT_TRUE(node0_accessible != nullptr);
528 
529  // Property lookups will be made against this node itself.
530  VARIANT varchild{};
531  varchild.vt = VT_I4;
532  varchild.lVal = CHILDID_SELF;
533 
534  // Verify node type is a group.
535  VARIANT varrole{};
536  varrole.vt = VT_I4;
537  ASSERT_EQ(node0_accessible->get_accRole(varchild, &varrole), S_OK);
538  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
539 
540  // Verify child count.
541  long node0_child_count = 0;
542  ASSERT_EQ(node0_accessible->get_accChildCount(&node0_child_count), S_OK);
543  EXPECT_EQ(node0_child_count, 2);
544 
545  {
546  // Look up first child of node0 (node1), a static text node.
547  varchild.lVal = 1;
548  IDispatch* node1_dispatch = nullptr;
549  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node1_dispatch), S_OK);
550  ASSERT_TRUE(node1_dispatch != nullptr);
551  IAccessible* node1_accessible = nullptr;
552  ASSERT_EQ(node1_dispatch->QueryInterface(
553  IID_IAccessible, reinterpret_cast<void**>(&node1_accessible)),
554  S_OK);
555  ASSERT_TRUE(node1_accessible != nullptr);
556 
557  // Verify node name matches our label.
558  varchild.lVal = CHILDID_SELF;
559  BSTR bname = nullptr;
560  ASSERT_EQ(node1_accessible->get_accName(varchild, &bname), S_OK);
561  std::string name(_com_util::ConvertBSTRToString(bname));
562  EXPECT_EQ(name, "prefecture");
563 
564  // Verify node value matches.
565  BSTR bvalue = nullptr;
566  ASSERT_EQ(node1_accessible->get_accValue(varchild, &bvalue), S_OK);
567  std::string value(_com_util::ConvertBSTRToString(bvalue));
568  EXPECT_EQ(value, "Kyoto");
569 
570  // Verify node type is static text.
571  VARIANT varrole{};
572  varrole.vt = VT_I4;
573  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
574  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
575 
576  // Verify the parent node is the root.
577  IDispatch* parent_dispatch;
578  node1_accessible->get_accParent(&parent_dispatch);
579  IAccessible* parent_accessible;
580  ASSERT_EQ(
581  parent_dispatch->QueryInterface(
582  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
583  S_OK);
584  EXPECT_EQ(parent_accessible, node0_accessible);
585  }
586 
587  // Look up second child of node0 (node2), a parent group for node3.
588  varchild.lVal = 2;
589  IDispatch* node2_dispatch = nullptr;
590  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
591  ASSERT_TRUE(node2_dispatch != nullptr);
592  IAccessible* node2_accessible = nullptr;
593  ASSERT_EQ(node2_dispatch->QueryInterface(
594  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
595  S_OK);
596  ASSERT_TRUE(node2_accessible != nullptr);
597 
598  {
599  // Verify child count.
600  long node2_child_count = 0;
601  ASSERT_EQ(node2_accessible->get_accChildCount(&node2_child_count), S_OK);
602  EXPECT_EQ(node2_child_count, 1);
603 
604  // Verify node type is static text.
605  varchild.lVal = CHILDID_SELF;
606  VARIANT varrole{};
607  varrole.vt = VT_I4;
608  ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
609  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
610 
611  // Verify the parent node is the root.
612  IDispatch* parent_dispatch;
613  node2_accessible->get_accParent(&parent_dispatch);
614  IAccessible* parent_accessible;
615  ASSERT_EQ(
616  parent_dispatch->QueryInterface(
617  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
618  S_OK);
619  EXPECT_EQ(parent_accessible, node0_accessible);
620  }
621 
622  {
623  // Look up only child of node2 (node3), a static text node.
624  varchild.lVal = 1;
625  IDispatch* node3_dispatch = nullptr;
626  ASSERT_EQ(node2_accessible->get_accChild(varchild, &node3_dispatch), S_OK);
627  ASSERT_TRUE(node3_dispatch != nullptr);
628  IAccessible* node3_accessible = nullptr;
629  ASSERT_EQ(node3_dispatch->QueryInterface(
630  IID_IAccessible, reinterpret_cast<void**>(&node3_accessible)),
631  S_OK);
632  ASSERT_TRUE(node3_accessible != nullptr);
633 
634  // Verify node name matches our label.
635  varchild.lVal = CHILDID_SELF;
636  BSTR bname = nullptr;
637  ASSERT_EQ(node3_accessible->get_accName(varchild, &bname), S_OK);
638  std::string name(_com_util::ConvertBSTRToString(bname));
639  EXPECT_EQ(name, "city");
640 
641  // Verify node value matches.
642  BSTR bvalue = nullptr;
643  ASSERT_EQ(node3_accessible->get_accValue(varchild, &bvalue), S_OK);
644  std::string value(_com_util::ConvertBSTRToString(bvalue));
645  EXPECT_EQ(value, "Uji");
646 
647  // Verify node type is static text.
648  VARIANT varrole{};
649  varrole.vt = VT_I4;
650  ASSERT_EQ(node3_accessible->get_accRole(varchild, &varrole), S_OK);
651  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
652 
653  // Verify the parent node is node2.
654  IDispatch* parent_dispatch;
655  node3_accessible->get_accParent(&parent_dispatch);
656  IAccessible* parent_accessible;
657  ASSERT_EQ(
658  parent_dispatch->QueryInterface(
659  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
660  S_OK);
661  EXPECT_EQ(parent_accessible, node2_accessible);
662  }
663 }

References node_delegate.

◆ TEST() [64/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
CheckboxNativeState   
)

Definition at line 1168 of file flutter_windows_view_unittests.cc.

1168  {
1169  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1170  EngineModifier modifier(engine.get());
1171  modifier.embedder_api().UpdateSemanticsEnabled =
1172  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1173  return kSuccess;
1174  };
1175 
1176  std::unique_ptr<FlutterWindowsView> view =
1177  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1178  /*is_sized_to_content=*/false, BoxConstraints());
1179 
1180  // Enable semantics to instantiate accessibility bridge.
1181  view->OnUpdateSemanticsEnabled(true);
1182 
1183  auto bridge = view->accessibility_bridge().lock();
1184  ASSERT_TRUE(bridge);
1185 
1186  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1187  root.id = 0;
1188  root.label = "root";
1189  root.hint = "";
1190  root.value = "";
1191  root.increased_value = "";
1192  root.decreased_value = "";
1193  root.child_count = 0;
1194  root.custom_accessibility_actions_count = 0;
1195  auto flags = FlutterSemanticsFlags{
1196  .is_checked = FlutterCheckState::kFlutterCheckStateTrue,
1197  };
1198  root.flags2 = &flags;
1199  bridge->AddFlutterSemanticsNodeUpdate(root);
1200 
1201  bridge->CommitUpdates();
1202 
1203  {
1204  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1205  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1206  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1207  ax::mojom::CheckedState::kTrue);
1208 
1209  // Get the IAccessible for the root node.
1210  IAccessible* native_view = root_node->GetNativeViewAccessible();
1211  ASSERT_TRUE(native_view != nullptr);
1212 
1213  // Look up against the node itself (not one of its children).
1214  VARIANT varchild = {};
1215  varchild.vt = VT_I4;
1216 
1217  // Verify the checkbox is checked.
1218  varchild.lVal = CHILDID_SELF;
1219  VARIANT native_state = {};
1220  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1221  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
1222 
1223  // Perform similar tests for UIA value;
1224  IRawElementProviderSimple* uia_node;
1225  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1226  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1227  UIA_ToggleToggleStatePropertyId, &native_state)));
1228  EXPECT_EQ(native_state.lVal, ToggleState_On);
1229 
1230  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1231  UIA_AriaPropertiesPropertyId, &native_state)));
1232  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=true"), nullptr);
1233  }
1234 
1235  // Test unchecked too.
1236  auto updated_flags = FlutterSemanticsFlags{
1237  .is_checked = FlutterCheckState::kFlutterCheckStateFalse,
1238  };
1239  root.flags2 = &updated_flags;
1240  bridge->AddFlutterSemanticsNodeUpdate(root);
1241  bridge->CommitUpdates();
1242 
1243  {
1244  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1245  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1246  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1247  ax::mojom::CheckedState::kFalse);
1248 
1249  // Get the IAccessible for the root node.
1250  IAccessible* native_view = root_node->GetNativeViewAccessible();
1251  ASSERT_TRUE(native_view != nullptr);
1252 
1253  // Look up against the node itself (not one of its children).
1254  VARIANT varchild = {};
1255  varchild.vt = VT_I4;
1256 
1257  // Verify the checkbox is unchecked.
1258  varchild.lVal = CHILDID_SELF;
1259  VARIANT native_state = {};
1260  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1261  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
1262 
1263  // Perform similar tests for UIA value;
1264  IRawElementProviderSimple* uia_node;
1265  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1266  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1267  UIA_ToggleToggleStatePropertyId, &native_state)));
1268  EXPECT_EQ(native_state.lVal, ToggleState_Off);
1269 
1270  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1271  UIA_AriaPropertiesPropertyId, &native_state)));
1272  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=false"), nullptr);
1273  }
1274 
1275  // Now check mixed state.
1276  auto updated_mixe_flags = FlutterSemanticsFlags{
1277  .is_checked = FlutterCheckState::kFlutterCheckStateMixed,
1278  };
1279  root.flags2 = &updated_mixe_flags;
1280  bridge->AddFlutterSemanticsNodeUpdate(root);
1281  bridge->CommitUpdates();
1282 
1283  {
1284  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1285  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1286  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1287  ax::mojom::CheckedState::kMixed);
1288 
1289  // Get the IAccessible for the root node.
1290  IAccessible* native_view = root_node->GetNativeViewAccessible();
1291  ASSERT_TRUE(native_view != nullptr);
1292 
1293  // Look up against the node itself (not one of its children).
1294  VARIANT varchild = {};
1295  varchild.vt = VT_I4;
1296 
1297  // Verify the checkbox is mixed.
1298  varchild.lVal = CHILDID_SELF;
1299  VARIANT native_state = {};
1300  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1301  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_MIXED);
1302 
1303  // Perform similar tests for UIA value;
1304  IRawElementProviderSimple* uia_node;
1305  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1306  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1307  UIA_ToggleToggleStatePropertyId, &native_state)));
1308  EXPECT_EQ(native_state.lVal, ToggleState_Indeterminate);
1309 
1310  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1311  UIA_AriaPropertiesPropertyId, &native_state)));
1312  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=mixed"), nullptr);
1313  }
1314 }

◆ TEST() [65/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
DisablesVSyncAfterStartup   
)

Definition at line 1573 of file flutter_windows_view_unittests.cc.

1573  {
1574  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1575  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1576  auto egl_manager = std::make_unique<egl::MockManager>();
1577  egl::MockContext render_context;
1578  auto surface = std::make_unique<egl::MockWindowSurface>();
1579  auto surface_ptr = surface.get();
1580 
1581  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1582  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1583  .WillOnce(Return(true));
1584 
1585  EXPECT_CALL(*egl_manager.get(), render_context)
1586  .WillOnce(Return(&render_context));
1587  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1588 
1589  InSequence s;
1590  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1591  .WillOnce(Return(std::move(surface)));
1592  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1593  .WillOnce([](fml::closure callback) {
1594  callback();
1595  return true;
1596  });
1597  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1598  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1599  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1600  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1601  .WillOnce([](fml::closure callback) {
1602  callback();
1603  return true;
1604  });
1605  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1606 
1607  EngineModifier modifier{engine.get()};
1608  modifier.SetEGLManager(std::move(egl_manager));
1609 
1610  std::unique_ptr<FlutterWindowsView> view =
1611  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1612  /*is_sized_to_content=*/false, BoxConstraints());
1613 }

References callback.

◆ TEST() [66/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
DisablesVSyncAtStartup   
)

Definition at line 1500 of file flutter_windows_view_unittests.cc.

1500  {
1501  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1502  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1503  auto egl_manager = std::make_unique<egl::MockManager>();
1504  egl::MockContext render_context;
1505  auto surface = std::make_unique<egl::MockWindowSurface>();
1506  auto surface_ptr = surface.get();
1507 
1508  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1509  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1510 
1511  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1512  .WillOnce(Return(true));
1513 
1514  EXPECT_CALL(*egl_manager.get(), render_context)
1515  .WillOnce(Return(&render_context));
1516  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1517 
1518  InSequence s;
1519  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1520  .WillOnce(Return(std::move(surface)));
1521  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1522  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1523  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1524 
1525  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1526 
1527  EngineModifier modifier{engine.get()};
1528  modifier.SetEGLManager(std::move(egl_manager));
1529 
1530  std::unique_ptr<FlutterWindowsView> view =
1531  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1532  /*is_sized_to_content=*/false, BoxConstraints());
1533 }

◆ TEST() [67/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
EnableSemantics   
)

Definition at line 347 of file flutter_windows_view_unittests.cc.

347  {
348  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
349  EngineModifier modifier(engine.get());
350 
351  bool semantics_enabled = false;
352  modifier.embedder_api().UpdateSemanticsEnabled = MOCK_ENGINE_PROC(
353  UpdateSemanticsEnabled,
354  [&semantics_enabled](FLUTTER_API_SYMBOL(FlutterEngine) engine,
355  bool enabled) {
356  semantics_enabled = enabled;
357  return kSuccess;
358  });
359 
360  auto window_binding_handler =
361  std::make_unique<NiceMock<MockWindowBindingHandler>>();
362  std::unique_ptr<FlutterWindowsView> view =
363  engine->CreateView(std::move(window_binding_handler),
364  /*is_sized_to_content=*/false, BoxConstraints());
365 
366  view->OnUpdateSemanticsEnabled(true);
367  EXPECT_TRUE(semantics_enabled);
368 }

◆ TEST() [68/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
EnablesVSyncAfterStartup   
)

Definition at line 1617 of file flutter_windows_view_unittests.cc.

1617  {
1618  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1619  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1620  auto egl_manager = std::make_unique<egl::MockManager>();
1621  egl::MockContext render_context;
1622  auto surface = std::make_unique<egl::MockWindowSurface>();
1623  auto surface_ptr = surface.get();
1624 
1625  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1626 
1627  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1628  .WillOnce(Return(false));
1629 
1630  EXPECT_CALL(*egl_manager.get(), render_context)
1631  .WillOnce(Return(&render_context));
1632  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1633 
1634  InSequence s;
1635  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1636  .WillOnce(Return(std::move(surface)));
1637  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1638  .WillOnce([](fml::closure callback) {
1639  callback();
1640  return true;
1641  });
1642 
1643  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1644  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1645  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1646 
1647  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1648  .WillOnce([](fml::closure callback) {
1649  callback();
1650  return true;
1651  });
1652  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1653 
1654  EngineModifier modifier{engine.get()};
1655  modifier.SetEGLManager(std::move(egl_manager));
1656 
1657  std::unique_ptr<FlutterWindowsView> view =
1658  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1659  /*is_sized_to_content=*/false, BoxConstraints());
1660 }

References callback.

◆ TEST() [69/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
EnablesVSyncAtStartup   
)

Definition at line 1537 of file flutter_windows_view_unittests.cc.

1537  {
1538  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1539  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1540  auto egl_manager = std::make_unique<egl::MockManager>();
1541  egl::MockContext render_context;
1542  auto surface = std::make_unique<egl::MockWindowSurface>();
1543  auto surface_ptr = surface.get();
1544 
1545  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1546  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1547  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1548  .WillOnce(Return(false));
1549 
1550  EXPECT_CALL(*egl_manager.get(), render_context)
1551  .WillOnce(Return(&render_context));
1552  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1553 
1554  InSequence s;
1555  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1556  .WillOnce(Return(std::move(surface)));
1557  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1558  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1559  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1560 
1561  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1562 
1563  EngineModifier modifier{engine.get()};
1564  modifier.SetEGLManager(std::move(egl_manager));
1565 
1566  std::unique_ptr<FlutterWindowsView> view =
1567  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1568  /*is_sized_to_content=*/false, BoxConstraints());
1569 }

◆ TEST() [70/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
FocusTriggersWindowFocus   
)

Definition at line 1727 of file flutter_windows_view_unittests.cc.

1727  {
1728  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1729  auto window_binding_handler =
1730  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1731  EXPECT_CALL(*window_binding_handler, Focus()).WillOnce(Return(true));
1732  std::unique_ptr<FlutterWindowsView> view =
1733  engine->CreateView(std::move(window_binding_handler),
1734  /*is_sized_to_content=*/false, BoxConstraints());
1735  EXPECT_TRUE(view->Focus());
1736 }

◆ TEST() [71/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
KeyEventCallback   
)

Definition at line 317 of file flutter_windows_view_unittests.cc.

317  {
318  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
319 
320  std::unique_ptr<FlutterWindowsView> view =
321  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
322  /*is_sized_to_content=*/false, BoxConstraints());
323 
324  class MockCallback {
325  public:
326  MOCK_METHOD(void, Call, ());
327  };
328 
329  NiceMock<MockCallback> callback_with_valid_view;
330  NiceMock<MockCallback> callback_with_invalid_view;
331 
332  auto trigger_key_event = [&](NiceMock<MockCallback>& callback) {
333  view->OnKey(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
334  [&](bool) { callback.Call(); });
335  };
336 
337  EXPECT_CALL(callback_with_valid_view, Call()).Times(1);
338  EXPECT_CALL(callback_with_invalid_view, Call()).Times(0);
339 
340  trigger_key_event(callback_with_valid_view);
341  engine->RemoveView(view->view_id());
342  trigger_key_event(callback_with_invalid_view);
343 
344  key_event_logs.clear();
345 }

References callback, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST() [72/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
KeySequence   
)

Definition at line 298 of file flutter_windows_view_unittests.cc.

298  {
299  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
300 
301  test_response = false;
302 
303  std::unique_ptr<FlutterWindowsView> view =
304  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
305  /*is_sized_to_content=*/false, BoxConstraints());
306 
307  view->OnKey(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
308  [](bool handled) {});
309 
310  EXPECT_EQ(key_event_logs.size(), 2);
311  EXPECT_EQ(key_event_logs[0], kKeyEventFromEmbedder);
312  EXPECT_EQ(key_event_logs[1], kKeyEventFromChannel);
313 
314  key_event_logs.clear();
315 }

References kScanCodeKeyA, and kVirtualKeyA.

◆ TEST() [73/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
NonZeroSemanticsRoot   
)

Definition at line 674 of file flutter_windows_view_unittests.cc.

674  {
675  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
676  EngineModifier modifier(engine.get());
677  modifier.embedder_api().UpdateSemanticsEnabled =
678  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
679  return kSuccess;
680  };
681 
682  std::unique_ptr<FlutterWindowsView> view =
683  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
684  /*is_sized_to_content=*/false, BoxConstraints());
685 
686  // Enable semantics to instantiate accessibility bridge.
687  view->OnUpdateSemanticsEnabled(true);
688 
689  auto bridge = view->accessibility_bridge().lock();
690  ASSERT_TRUE(bridge);
691 
692  // Add root node.
693  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
694  std::vector<int32_t> node1_children{2};
695  node1.child_count = node1_children.size();
696  node1.children_in_traversal_order = node1_children.data();
697  node1.children_in_hit_test_order = node1_children.data();
698  auto empty_flags = FlutterSemanticsFlags{};
699  node1.flags2 = &empty_flags;
700 
701  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
702  node2.label = "prefecture";
703  node2.value = "Kyoto";
704  node2.flags2 = &empty_flags;
705  bridge->AddFlutterSemanticsNodeUpdate(node1);
706  bridge->AddFlutterSemanticsNodeUpdate(node2);
707  bridge->CommitUpdates();
708 
709  // Look up the root windows node delegate.
710  auto root_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
711  ASSERT_TRUE(root_delegate);
712  EXPECT_EQ(root_delegate->GetChildCount(), 1);
713 
714  // Look up the child node delegate
715  auto child_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
716  ASSERT_TRUE(child_delegate);
717  EXPECT_EQ(child_delegate->GetChildCount(), 0);
718 
719  // Ensure a node with ID 0 does not exist.
720  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
721  ASSERT_FALSE(fake_delegate);
722 
723  // Get the root's native IAccessible object.
724  IAccessible* node1_accessible = root_delegate->GetNativeViewAccessible();
725  ASSERT_TRUE(node1_accessible != nullptr);
726 
727  // Property lookups will be made against this node itself.
728  VARIANT varchild{};
729  varchild.vt = VT_I4;
730  varchild.lVal = CHILDID_SELF;
731 
732  // Verify node type is a group.
733  VARIANT varrole{};
734  varrole.vt = VT_I4;
735  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
736  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
737 
738  // Verify child count.
739  long node1_child_count = 0;
740  ASSERT_EQ(node1_accessible->get_accChildCount(&node1_child_count), S_OK);
741  EXPECT_EQ(node1_child_count, 1);
742 
743  {
744  // Look up first child of node1 (node0), a static text node.
745  varchild.lVal = 1;
746  IDispatch* node2_dispatch = nullptr;
747  ASSERT_EQ(node1_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
748  ASSERT_TRUE(node2_dispatch != nullptr);
749  IAccessible* node2_accessible = nullptr;
750  ASSERT_EQ(node2_dispatch->QueryInterface(
751  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
752  S_OK);
753  ASSERT_TRUE(node2_accessible != nullptr);
754 
755  // Verify node name matches our label.
756  varchild.lVal = CHILDID_SELF;
757  BSTR bname = nullptr;
758  ASSERT_EQ(node2_accessible->get_accName(varchild, &bname), S_OK);
759  std::string name(_com_util::ConvertBSTRToString(bname));
760  EXPECT_EQ(name, "prefecture");
761 
762  // Verify node value matches.
763  BSTR bvalue = nullptr;
764  ASSERT_EQ(node2_accessible->get_accValue(varchild, &bvalue), S_OK);
765  std::string value(_com_util::ConvertBSTRToString(bvalue));
766  EXPECT_EQ(value, "Kyoto");
767 
768  // Verify node type is static text.
769  VARIANT varrole{};
770  varrole.vt = VT_I4;
771  ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
772  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
773 
774  // Verify the parent node is the root.
775  IDispatch* parent_dispatch;
776  node2_accessible->get_accParent(&parent_dispatch);
777  IAccessible* parent_accessible;
778  ASSERT_EQ(
779  parent_dispatch->QueryInterface(
780  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
781  S_OK);
782  EXPECT_EQ(parent_accessible, node1_accessible);
783  }
784 }

◆ TEST() [74/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
OnFocusTriggersSendFocusViewEvent   
)

Definition at line 1738 of file flutter_windows_view_unittests.cc.

1738  {
1739  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1740  auto window_binding_handler =
1741  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1742  std::unique_ptr<FlutterWindowsView> view =
1743  engine->CreateView(std::move(window_binding_handler),
1744  /*is_sized_to_content=*/false, BoxConstraints());
1745 
1746  EngineModifier modifier(engine.get());
1747  bool received_focus_event = false;
1748  modifier.embedder_api().SendViewFocusEvent = MOCK_ENGINE_PROC(
1749  SendViewFocusEvent, [&](FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
1750  FlutterViewFocusEvent const* event) {
1751  EXPECT_EQ(event->state, FlutterViewFocusState::kFocused);
1752  EXPECT_EQ(event->direction, FlutterViewFocusDirection::kUndefined);
1753  EXPECT_EQ(event->view_id, view->view_id());
1754  EXPECT_EQ(event->struct_size, sizeof(FlutterViewFocusEvent));
1755  received_focus_event = true;
1756  return kSuccess;
1757  });
1758  view->OnFocus(FlutterViewFocusState::kFocused,
1759  FlutterViewFocusDirection::kUndefined);
1760  EXPECT_TRUE(received_focus_event);
1761 }

◆ TEST() [75/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
Shutdown   
)

Definition at line 247 of file flutter_windows_view_unittests.cc.

247  {
248  auto engine = std::make_unique<MockFlutterWindowsEngine>();
249  auto window_binding_handler =
250  std::make_unique<NiceMock<MockWindowBindingHandler>>();
251  auto egl_manager = std::make_unique<egl::MockManager>();
252  auto surface = std::make_unique<egl::MockWindowSurface>();
253  egl::MockContext render_context;
254 
255  auto engine_ptr = engine.get();
256  auto surface_ptr = surface.get();
257  auto egl_manager_ptr = egl_manager.get();
258 
259  EngineModifier modifier{engine.get()};
260  modifier.SetEGLManager(std::move(egl_manager));
261 
262  InSequence s;
263  std::unique_ptr<FlutterWindowsView> view;
264 
265  // Mock render surface initialization.
266  {
267  EXPECT_CALL(*egl_manager_ptr, CreateWindowSurface)
268  .WillOnce(Return(std::move(surface)));
269  EXPECT_CALL(*engine_ptr, running).WillOnce(Return(false));
270  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
271  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
272  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
273  EXPECT_CALL(*egl_manager_ptr, render_context)
274  .WillOnce(Return(&render_context));
275  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
276 
277  view = engine->CreateView(std::move(window_binding_handler), false,
278  BoxConstraints());
279  }
280 
281  // The view must be removed before the surface can be destroyed.
282  {
283  auto view_id = view->view_id();
284  FlutterWindowsViewController controller{std::move(engine), std::move(view)};
285 
286  EXPECT_CALL(*engine_ptr, running).WillOnce(Return(true));
287  EXPECT_CALL(*engine_ptr, RemoveView(view_id)).Times(1);
288  EXPECT_CALL(*engine_ptr, running).WillOnce(Return(true));
289  EXPECT_CALL(*engine_ptr, PostRasterThreadTask)
290  .WillOnce([](fml::closure callback) {
291  callback();
292  return true;
293  });
294  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
295  }
296 }

References callback.

◆ TEST() [76/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
SizeChangeTriggersMetricsEventWhichHasDisplayId   
)

Definition at line 1779 of file flutter_windows_view_unittests.cc.

1779  {
1780  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1781  EngineModifier modifier(engine.get());
1782 
1783  auto window_binding_handler =
1784  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1785  EXPECT_CALL(*window_binding_handler, GetDisplayId)
1786  .WillOnce(testing::Return(12));
1787  FlutterWindowsView view{kImplicitViewId, engine.get(),
1788  std::move(window_binding_handler), false,
1789  BoxConstraints()};
1790 
1791  bool received_metrics = false;
1792  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1793  SendWindowMetricsEvent,
1794  ([&received_metrics](auto engine,
1795  const FlutterWindowMetricsEvent* event) {
1796  received_metrics = true;
1797  EXPECT_EQ(event->display_id, 12);
1798  return kSuccess;
1799  }));
1800  view.OnWindowSizeChanged(100, 100);
1801  EXPECT_TRUE(received_metrics);
1802 }
flutter::kImplicitViewId
constexpr FlutterViewId kImplicitViewId
Definition: flutter_windows_engine.h:56

References flutter::kImplicitViewId.

◆ TEST() [77/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
SubMenuExpandedState   
)

Definition at line 137 of file flutter_windows_view_unittests.cc.

137  {
138  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
139  EngineModifier modifier(engine.get());
140  modifier.embedder_api().UpdateSemanticsEnabled =
141  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
142  return kSuccess;
143  };
144 
145  auto window_binding_handler =
146  std::make_unique<NiceMock<MockWindowBindingHandler>>();
147  std::unique_ptr<FlutterWindowsView> view =
148  engine->CreateView(std::move(window_binding_handler),
149  /*is_sized_to_content=*/false, BoxConstraints());
150 
151  // Enable semantics to instantiate accessibility bridge.
152  view->OnUpdateSemanticsEnabled(true);
153 
154  auto bridge = view->accessibility_bridge().lock();
155  ASSERT_TRUE(bridge);
156 
157  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
158  root.id = 0;
159  root.label = "root";
160  root.hint = "";
161  root.value = "";
162  root.increased_value = "";
163  root.decreased_value = "";
164  root.child_count = 0;
165  root.custom_accessibility_actions_count = 0;
166  auto flags = FlutterSemanticsFlags{
167  .is_expanded = FlutterTristate::kFlutterTristateTrue,
168  };
169  root.flags2 = &flags;
170 
171  bridge->AddFlutterSemanticsNodeUpdate(root);
172 
173  bridge->CommitUpdates();
174 
175  {
176  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
177  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kExpanded));
178 
179  // Get the IAccessible for the root node.
180  IAccessible* native_view = root_node->GetNativeViewAccessible();
181  ASSERT_TRUE(native_view != nullptr);
182 
183  // Look up against the node itself (not one of its children).
184  VARIANT varchild = {};
185  varchild.vt = VT_I4;
186 
187  // Verify the submenu is expanded.
188  varchild.lVal = CHILDID_SELF;
189  VARIANT native_state = {};
190  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
191  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_EXPANDED);
192 
193  // Perform similar tests for UIA value;
194  IRawElementProviderSimple* uia_node;
195  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
196  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
197  UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
198  EXPECT_EQ(native_state.lVal, ExpandCollapseState_Expanded);
199 
200  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
201  UIA_AriaPropertiesPropertyId, &native_state)));
202  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=true"), nullptr);
203  }
204 
205  // Test collapsed too.
206  auto updated_flags = FlutterSemanticsFlags{
207  .is_expanded = FlutterTristate::kFlutterTristateFalse,
208  };
209  root.flags2 = &updated_flags;
210 
211  bridge->AddFlutterSemanticsNodeUpdate(root);
212  bridge->CommitUpdates();
213 
214  {
215  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
216  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kCollapsed));
217 
218  // Get the IAccessible for the root node.
219  IAccessible* native_view = root_node->GetNativeViewAccessible();
220  ASSERT_TRUE(native_view != nullptr);
221 
222  // Look up against the node itself (not one of its children).
223  VARIANT varchild = {};
224  varchild.vt = VT_I4;
225 
226  // Verify the submenu is collapsed.
227  varchild.lVal = CHILDID_SELF;
228  VARIANT native_state = {};
229  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
230  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_COLLAPSED);
231 
232  // Perform similar tests for UIA value;
233  IRawElementProviderSimple* uia_node;
234  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
235  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
236  UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
237  EXPECT_EQ(native_state.lVal, ExpandCollapseState_Collapsed);
238 
239  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
240  UIA_AriaPropertiesPropertyId, &native_state)));
241  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=false"), nullptr);
242  }
243 }

◆ TEST() [78/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
SwitchNativeState   
)

Definition at line 1317 of file flutter_windows_view_unittests.cc.

1317  {
1318  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1319  EngineModifier modifier(engine.get());
1320  modifier.embedder_api().UpdateSemanticsEnabled =
1321  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1322  return kSuccess;
1323  };
1324 
1325  std::unique_ptr<FlutterWindowsView> view =
1326  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1327  /*is_sized_to_content=*/false, BoxConstraints());
1328 
1329  // Enable semantics to instantiate accessibility bridge.
1330  view->OnUpdateSemanticsEnabled(true);
1331 
1332  auto bridge = view->accessibility_bridge().lock();
1333  ASSERT_TRUE(bridge);
1334 
1335  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1336  root.id = 0;
1337  root.label = "root";
1338  root.hint = "";
1339  root.value = "";
1340  root.increased_value = "";
1341  root.decreased_value = "";
1342  root.child_count = 0;
1343  root.custom_accessibility_actions_count = 0;
1344 
1345  auto flags = FlutterSemanticsFlags{
1346  .is_toggled = FlutterTristate::kFlutterTristateTrue,
1347  };
1348  root.flags2 = &flags;
1349  bridge->AddFlutterSemanticsNodeUpdate(root);
1350 
1351  bridge->CommitUpdates();
1352 
1353  {
1354  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1355  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
1356  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1357  ax::mojom::CheckedState::kTrue);
1358 
1359  // Get the IAccessible for the root node.
1360  IAccessible* native_view = root_node->GetNativeViewAccessible();
1361  ASSERT_TRUE(native_view != nullptr);
1362 
1363  // Look up against the node itself (not one of its children).
1364  VARIANT varchild = {};
1365  varchild.vt = VT_I4;
1366 
1367  varchild.lVal = CHILDID_SELF;
1368  VARIANT varrole = {};
1369 
1370  // Verify the role of the switch is CHECKBUTTON
1371  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
1372  ASSERT_EQ(varrole.lVal, ROLE_SYSTEM_CHECKBUTTON);
1373 
1374  // Verify the switch is pressed.
1375  VARIANT native_state = {};
1376  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1377  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_PRESSED);
1378  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
1379 
1380  // Test similarly on UIA node.
1381  IRawElementProviderSimple* uia_node;
1382  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1383  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
1384  S_OK);
1385  EXPECT_EQ(varrole.lVal, UIA_ButtonControlTypeId);
1386  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1387  &native_state),
1388  S_OK);
1389  EXPECT_EQ(native_state.lVal, ToggleState_On);
1390  ASSERT_EQ(
1391  uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1392  S_OK);
1393  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=true"), nullptr);
1394  }
1395 
1396  // Test unpressed too.
1397  auto updated_flags = FlutterSemanticsFlags{
1398  .is_toggled = FlutterTristate::kFlutterTristateFalse,
1399  };
1400  root.flags2 = &updated_flags;
1401 
1402  bridge->AddFlutterSemanticsNodeUpdate(root);
1403  bridge->CommitUpdates();
1404 
1405  {
1406  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1407  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
1408  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1409  ax::mojom::CheckedState::kFalse);
1410 
1411  // Get the IAccessible for the root node.
1412  IAccessible* native_view = root_node->GetNativeViewAccessible();
1413  ASSERT_TRUE(native_view != nullptr);
1414 
1415  // Look up against the node itself (not one of its children).
1416  VARIANT varchild = {};
1417  varchild.vt = VT_I4;
1418 
1419  // Verify the switch is not pressed.
1420  varchild.lVal = CHILDID_SELF;
1421  VARIANT native_state = {};
1422  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1423  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_PRESSED);
1424  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
1425 
1426  // Test similarly on UIA node.
1427  IRawElementProviderSimple* uia_node;
1428  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1429  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1430  &native_state),
1431  S_OK);
1432  EXPECT_EQ(native_state.lVal, ToggleState_Off);
1433  ASSERT_EQ(
1434  uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1435  S_OK);
1436  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=false"), nullptr);
1437  }
1438 }

◆ TEST() [79/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
TestEmptyFrameResizes   
)

Definition at line 973 of file flutter_windows_view_unittests.cc.

973  {
974  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
975  std::unique_ptr<FlutterWindowsEngine> engine =
976  GetTestEngine(windows_proc_table);
977 
978  EngineModifier engine_modifier{engine.get()};
979  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
980  PostRenderThreadTask,
981  ([](auto engine, VoidCallback callback, void* user_data) {
982  callback(user_data);
983  return kSuccess;
984  }));
985 
986  auto egl_manager = std::make_unique<egl::MockManager>();
987  auto surface = std::make_unique<egl::MockWindowSurface>();
988  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
989  auto resized_surface_ptr = resized_surface.get();
990 
991  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
992  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
993 
994  EXPECT_CALL(*egl_manager.get(),
995  CreateWindowSurface(_, /*width=*/500, /*height=*/500))
996  .WillOnce(Return(std::move((resized_surface))));
997  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
998  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
999  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
1000 
1001  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
1002 
1003  fml::AutoResetWaitableEvent metrics_sent_latch;
1004  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1005  SendWindowMetricsEvent,
1006  ([&metrics_sent_latch](auto engine,
1007  const FlutterWindowMetricsEvent* event) {
1008  metrics_sent_latch.Signal();
1009  return kSuccess;
1010  }));
1011 
1012  std::unique_ptr<FlutterWindowsView> view =
1013  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1014  /*is_sized_to_content=*/false, BoxConstraints());
1015 
1016  ViewModifier view_modifier{view.get()};
1017  engine_modifier.SetEGLManager(std::move(egl_manager));
1018  view_modifier.SetSurface(std::move(surface));
1019 
1020  // Simulate raster thread.
1021  std::thread frame_thread([&metrics_sent_latch, &view]() {
1022  metrics_sent_latch.Wait();
1023 
1024  // Empty frame generated and presented from the raster thread.
1025  EXPECT_TRUE(view->OnEmptyFrameGenerated());
1026  view->OnFramePresented();
1027  });
1028 
1029  // Start the window resize. This sends the new window metrics
1030  // and then blocks until another thread completes the window resize.
1031  EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
1032  frame_thread.join();
1033 }
VoidCallback
void(* VoidCallback)(void *)
Definition: flutter_windows.h:21

References callback, and user_data.

◆ TEST() [80/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
TooltipNodeData   
)

Definition at line 1440 of file flutter_windows_view_unittests.cc.

1440  {
1441  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1442  EngineModifier modifier(engine.get());
1443  modifier.embedder_api().UpdateSemanticsEnabled =
1444  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1445  return kSuccess;
1446  };
1447 
1448  std::unique_ptr<FlutterWindowsView> view =
1449  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1450  /*is_sized_to_content=*/false, BoxConstraints());
1451 
1452  // Enable semantics to instantiate accessibility bridge.
1453  view->OnUpdateSemanticsEnabled(true);
1454 
1455  auto bridge = view->accessibility_bridge().lock();
1456  ASSERT_TRUE(bridge);
1457 
1458  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1459  root.id = 0;
1460  root.label = "root";
1461  root.hint = "";
1462  root.value = "";
1463  root.increased_value = "";
1464  root.decreased_value = "";
1465  root.tooltip = "tooltip";
1466  root.child_count = 0;
1467  root.custom_accessibility_actions_count = 0;
1468  auto flags = FlutterSemanticsFlags{
1469  .is_text_field = true,
1470  };
1471  root.flags2 = &flags;
1472  bridge->AddFlutterSemanticsNodeUpdate(root);
1473 
1474  bridge->CommitUpdates();
1475  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1476  std::string tooltip = root_node->GetData().GetStringAttribute(
1477  ax::mojom::StringAttribute::kTooltip);
1478  EXPECT_EQ(tooltip, "tooltip");
1479 
1480  // Check that MSAA name contains the tooltip.
1481  IAccessible* native_view = bridge->GetFlutterPlatformNodeDelegateFromID(0)
1482  .lock()
1483  ->GetNativeViewAccessible();
1484  VARIANT varchild = {.vt = VT_I4, .lVal = CHILDID_SELF};
1485  BSTR bname;
1486  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
1487  EXPECT_NE(std::wcsstr(bname, L"tooltip"), nullptr);
1488 
1489  // Check that UIA help text is equal to the tooltip.
1490  IRawElementProviderSimple* uia_node;
1491  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1492  VARIANT varname{};
1493  ASSERT_EQ(uia_node->GetPropertyValue(UIA_HelpTextPropertyId, &varname), S_OK);
1494  std::string uia_tooltip = _com_util::ConvertBSTRToString(varname.bstrVal);
1495  EXPECT_EQ(uia_tooltip, "tooltip");
1496 }

◆ TEST() [81/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
UpdatesVSyncOnDwmUpdates   
)

Definition at line 1665 of file flutter_windows_view_unittests.cc.

1665  {
1666  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1667  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1668  auto egl_manager = std::make_unique<egl::MockManager>();
1669  egl::MockContext render_context;
1670  auto surface = std::make_unique<egl::MockWindowSurface>();
1671  auto surface_ptr = surface.get();
1672 
1673  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1674 
1675  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1676  .WillRepeatedly([](fml::closure callback) {
1677  callback();
1678  return true;
1679  });
1680 
1681  EXPECT_CALL(*egl_manager.get(), render_context)
1682  .WillRepeatedly(Return(&render_context));
1683 
1684  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
1685  EXPECT_CALL(*surface_ptr, MakeCurrent).WillRepeatedly(Return(true));
1686  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1687  EXPECT_CALL(render_context, ClearCurrent).WillRepeatedly(Return(true));
1688 
1689  InSequence s;
1690 
1691  // Mock render surface initialization.
1692  std::unique_ptr<FlutterWindowsView> view;
1693  {
1694  EXPECT_CALL(*egl_manager, CreateWindowSurface)
1695  .WillOnce(Return(std::move(surface)));
1696  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1697  .WillOnce(Return(true));
1698  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
1699 
1700  EngineModifier engine_modifier{engine.get()};
1701  engine_modifier.SetEGLManager(std::move(egl_manager));
1702 
1703  view = engine->CreateView(
1704  std::make_unique<NiceMock<MockWindowBindingHandler>>(), false,
1705  BoxConstraints());
1706  }
1707 
1708  // Disabling DWM composition should enable vsync blocking on the surface.
1709  {
1710  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1711  .WillOnce(Return(false));
1712  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1713 
1714  engine->OnDwmCompositionChanged();
1715  }
1716 
1717  // Enabling DWM composition should disable vsync blocking on the surface.
1718  {
1719  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1720  .WillOnce(Return(true));
1721  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1722 
1723  engine->OnDwmCompositionChanged();
1724  }
1725 }

References callback.

◆ TEST() [82/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
WindowMetricsEventContainsDisplayId   
)

Definition at line 1763 of file flutter_windows_view_unittests.cc.

1763  {
1764  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1765  EngineModifier modifier(engine.get());
1766 
1767  auto window_binding_handler =
1768  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1769  EXPECT_CALL(*window_binding_handler, GetDisplayId)
1770  .WillOnce(testing::Return(12));
1771  FlutterWindowsView view{kImplicitViewId, engine.get(),
1772  std::move(window_binding_handler), false,
1773  BoxConstraints()};
1774 
1775  FlutterWindowMetricsEvent event = view.CreateWindowMetricsEvent();
1776  EXPECT_EQ(event.display_id, 12);
1777 }

References flutter::kImplicitViewId.

◆ TEST() [83/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
WindowRepaintTests   
)

Definition at line 1142 of file flutter_windows_view_unittests.cc.

1142  {
1143  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1144  EngineModifier modifier(engine.get());
1145 
1146  FlutterWindowsView view{kImplicitViewId, engine.get(),
1147  std::make_unique<flutter::FlutterWindow>(
1148  100, 100, engine->display_manager()),
1149  /*is_sized_to_content=*/false, BoxConstraints()};
1150 
1151  bool schedule_frame_called = false;
1152  modifier.embedder_api().ScheduleFrame =
1153  MOCK_ENGINE_PROC(ScheduleFrame, ([&schedule_frame_called](auto engine) {
1154  schedule_frame_called = true;
1155  return kSuccess;
1156  }));
1157 
1158  view.OnWindowRepaint();
1159  EXPECT_TRUE(schedule_frame_called);
1160 }

References flutter::kImplicitViewId.

◆ TEST() [84/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
WindowResizeInvalidSurface   
)

Definition at line 1078 of file flutter_windows_view_unittests.cc.

1078  {
1079  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1080 
1081  EngineModifier engine_modifier(engine.get());
1082  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1083  PostRenderThreadTask,
1084  ([](auto engine, VoidCallback callback, void* user_data) {
1085  callback(user_data);
1086  return kSuccess;
1087  }));
1088 
1089  auto egl_manager = std::make_unique<egl::MockManager>();
1090  auto surface = std::make_unique<egl::MockWindowSurface>();
1091 
1092  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1093  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(false));
1094  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(false));
1095 
1096  std::unique_ptr<FlutterWindowsView> view =
1097  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1098  /*is_sized_to_content=*/false, BoxConstraints());
1099 
1100  ViewModifier view_modifier{view.get()};
1101  engine_modifier.SetEGLManager(std::move(egl_manager));
1102  view_modifier.SetSurface(std::move(surface));
1103 
1104  auto metrics_sent = false;
1105  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1106  SendWindowMetricsEvent,
1107  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1108  metrics_sent = true;
1109  return kSuccess;
1110  }));
1111 
1112  view->OnWindowSizeChanged(500, 500);
1113 }

References callback, and user_data.

◆ TEST() [85/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
WindowResizeRace   
)

Definition at line 1038 of file flutter_windows_view_unittests.cc.

1038  {
1039  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1040 
1041  EngineModifier engine_modifier(engine.get());
1042  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1043  PostRenderThreadTask,
1044  ([](auto engine, VoidCallback callback, void* user_data) {
1045  callback(user_data);
1046  return kSuccess;
1047  }));
1048 
1049  auto egl_manager = std::make_unique<egl::MockManager>();
1050  auto surface = std::make_unique<egl::MockWindowSurface>();
1051 
1052  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
1053  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
1054 
1055  std::unique_ptr<FlutterWindowsView> view =
1056  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1057  /*is_sized_to_content=*/false, BoxConstraints());
1058 
1059  ViewModifier view_modifier{view.get()};
1060  engine_modifier.SetEGLManager(std::move(egl_manager));
1061  view_modifier.SetSurface(std::move(surface));
1062 
1063  // Begin a frame.
1064  ASSERT_TRUE(view->OnFrameGenerated(100, 100));
1065 
1066  // Inject a window resize between the frame generation and
1067  // frame presentation. The new size invalidates the current frame.
1068  EXPECT_FALSE(view->OnWindowSizeChanged(500, 500));
1069 
1070  // Complete the invalidated frame while a resize is pending. Although this
1071  // might mean that we presented a frame with the wrong size, this should not
1072  // crash the app.
1073  view->OnFramePresented();
1074 }

References callback, and user_data.

◆ TEST() [86/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
WindowResizeTests   
)

Definition at line 901 of file flutter_windows_view_unittests.cc.

901  {
902  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
903  std::unique_ptr<FlutterWindowsEngine> engine =
904  GetTestEngine(windows_proc_table);
905 
906  EngineModifier engine_modifier{engine.get()};
907  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
908  PostRenderThreadTask,
909  ([](auto engine, VoidCallback callback, void* user_data) {
910  callback(user_data);
911  return kSuccess;
912  }));
913 
914  auto egl_manager = std::make_unique<egl::MockManager>();
915  auto surface = std::make_unique<egl::MockWindowSurface>();
916  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
917  egl::MockContext render_context;
918 
919  auto surface_ptr = surface.get();
920  auto resized_surface_ptr = resized_surface.get();
921 
922  // Mock render surface creation
923  EXPECT_CALL(*egl_manager, CreateWindowSurface)
924  .WillOnce(Return(std::move(surface)));
925  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
926  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
927  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
928  EXPECT_CALL(*egl_manager, render_context).WillOnce(Return(&render_context));
929  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
930 
931  // Mock render surface resize
932  EXPECT_CALL(*surface_ptr, Destroy).WillOnce(Return(true));
933  EXPECT_CALL(*egl_manager.get(),
934  CreateWindowSurface(_, /*width=*/500, /*height=*/500))
935  .WillOnce(Return(std::move((resized_surface))));
936  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
937  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
938  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
939 
940  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
941 
942  engine_modifier.SetEGLManager(std::move(egl_manager));
943 
944  std::unique_ptr<FlutterWindowsView> view =
945  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
946  /*is_sized_to_content=*/false, BoxConstraints());
947 
948  fml::AutoResetWaitableEvent metrics_sent_latch;
949  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
950  SendWindowMetricsEvent,
951  ([&metrics_sent_latch](auto engine,
952  const FlutterWindowMetricsEvent* event) {
953  metrics_sent_latch.Signal();
954  return kSuccess;
955  }));
956 
957  // Simulate raster thread.
958  std::thread frame_thread([&metrics_sent_latch, &view]() {
959  metrics_sent_latch.Wait();
960  // Frame generated and presented from the raster thread.
961  EXPECT_TRUE(view->OnFrameGenerated(500, 500));
962  view->OnFramePresented();
963  });
964 
965  // Start the window resize. This sends the new window metrics
966  // and then blocks polling run loop until another thread completes the window
967  // resize.
968  EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
969  frame_thread.join();
970 }

References callback, and user_data.

◆ TEST() [87/165]

flutter::testing::TEST ( FlutterWindowsViewTest  ,
WindowResizeWithoutSurface   
)

Definition at line 1117 of file flutter_windows_view_unittests.cc.

1117  {
1118  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1119  EngineModifier modifier(engine.get());
1120 
1121  auto egl_manager = std::make_unique<egl::MockManager>();
1122 
1123  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1124 
1125  std::unique_ptr<FlutterWindowsView> view =
1126  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1127  /*is_sized_to_content=*/false, BoxConstraints());
1128 
1129  modifier.SetEGLManager(std::move(egl_manager));
1130 
1131  auto metrics_sent = false;
1132  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1133  SendWindowMetricsEvent,
1134  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1135  metrics_sent = true;
1136  return kSuccess;
1137  }));
1138 
1139  view->OnWindowSizeChanged(500, 500);
1140 }

◆ TEST() [88/165]

flutter::testing::TEST ( KeyboardKeyChannelHandlerTest  ,
DeadKeysDoNotCrash   
)

Definition at line 128 of file keyboard_key_channel_handler_unittests.cc.

128  {
129  bool received = false;
130  TestBinaryMessenger messenger(
131  [&received](const std::string& channel, const uint8_t* message,
132  size_t message_size, BinaryReply reply) {
133  if (channel == "flutter/keyevent") {
134  auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
135  message, message_size);
136  uint32_t character = (*message_doc)[kCharacterCodePointKey].GetUint();
137  EXPECT_EQ(character, (uint32_t)'^');
138  received = true;
139  }
140  return true;
141  });
142 
143  KeyboardKeyChannelHandler handler(&messenger);
144  // Extended key flag is passed to redispatched events if set.
145  handler.KeyboardHook(0xDD, 0x1a, WM_KEYDOWN, 0x8000005E, false, false,
146  [](bool handled) {});
147 
148  // EXPECT is done during the callback above.
149  EXPECT_TRUE(received);
150 }
character
char32_t character
Definition: keyboard_key_handler_unittests.cc:117
message
Win32Message message
Definition: keyboard_unittests.cc:137
flutter::BinaryReply
std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
Definition: binary_messenger.h:18

References character, flutter::MessageCodec< T >::DecodeMessage(), flutter::JsonMessageCodec::GetInstance(), and message.

◆ TEST() [89/165]

flutter::testing::TEST ( KeyboardKeyChannelHandlerTest  ,
EmptyResponsesDoNotCrash   
)

Definition at line 152 of file keyboard_key_channel_handler_unittests.cc.

152  {
153  bool received = false;
154  TestBinaryMessenger messenger(
155  [&received](const std::string& channel, const uint8_t* message,
156  size_t message_size, BinaryReply reply) {
157  if (channel == "flutter/keyevent") {
158  std::string empty_message = "";
159  std::vector<uint8_t> empty_response(empty_message.begin(),
160  empty_message.end());
161  reply(empty_response.data(), empty_response.size());
162  received = true;
163  }
164  return true;
165  });
166 
167  KeyboardKeyChannelHandler handler(&messenger);
168  handler.KeyboardHook(64, kUnhandledScanCode, WM_KEYDOWN, L'b', false, false,
169  [](bool handled) {});
170 
171  // Passes if it does not crash.
172  EXPECT_TRUE(received);
173 }

References message.

◆ TEST() [90/165]

flutter::testing::TEST ( KeyboardKeyChannelHandlerTest  ,
ExtendedKeysAreSentToRedispatch   
)

Definition at line 88 of file keyboard_key_channel_handler_unittests.cc.

88  {
89  auto handled_message = CreateResponse(true);
90  auto unhandled_message = CreateResponse(false);
91  int received_scancode = 0;
92 
93  TestBinaryMessenger messenger(
94  [&received_scancode, &handled_message, &unhandled_message](
95  const std::string& channel, const uint8_t* message,
96  size_t message_size, BinaryReply reply) {
97  if (channel == "flutter/keyevent") {
98  auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
99  message, message_size);
100  received_scancode = (*message_doc)[kScanCodeKey].GetInt();
101  if (received_scancode == kHandledScanCode) {
102  reply(handled_message->data(), handled_message->size());
103  } else {
104  reply(unhandled_message->data(), unhandled_message->size());
105  }
106  }
107  });
108 
109  KeyboardKeyChannelHandler handler(&messenger);
110  bool last_handled = true;
111 
112  // Extended key flag is passed to redispatched events if set.
113  handler.KeyboardHook(
114  64, kUnhandledScanCode, WM_KEYDOWN, L'b', true, false,
115  [&last_handled](bool handled) { last_handled = handled; });
116  EXPECT_EQ(last_handled, false);
117  EXPECT_EQ(received_scancode, kUnhandledScanCodeExtended);
118 
119  last_handled = true;
120  // Extended key flag is not passed to redispatched events if not set.
121  handler.KeyboardHook(
122  64, kUnhandledScanCode, WM_KEYDOWN, L'b', false, false,
123  [&last_handled](bool handled) { last_handled = handled; });
124  EXPECT_EQ(last_handled, false);
125  EXPECT_EQ(received_scancode, kUnhandledScanCode);
126 }

References flutter::MessageCodec< T >::DecodeMessage(), flutter::JsonMessageCodec::GetInstance(), and message.

◆ TEST() [91/165]

flutter::testing::TEST ( KeyboardKeyChannelHandlerTest  ,
KeyboardHookHandling   
)

Definition at line 33 of file keyboard_key_channel_handler_unittests.cc.

33  {
34  auto handled_message = CreateResponse(true);
35  auto unhandled_message = CreateResponse(false);
36  int received_scancode = 0;
37 
38  TestBinaryMessenger messenger(
39  [&received_scancode, &handled_message, &unhandled_message](
40  const std::string& channel, const uint8_t* message,
41  size_t message_size, BinaryReply reply) {
42  if (channel == "flutter/keyevent") {
43  auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
44  message, message_size);
45  received_scancode = (*message_doc)[kScanCodeKey].GetInt();
46  if (received_scancode == kHandledScanCode) {
47  reply(handled_message->data(), handled_message->size());
48  } else {
49  reply(unhandled_message->data(), unhandled_message->size());
50  }
51  }
52  });
53 
54  KeyboardKeyChannelHandler handler(&messenger);
55  bool last_handled = false;
56 
57  handler.KeyboardHook(
58  64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
59  [&last_handled](bool handled) { last_handled = handled; });
60  EXPECT_EQ(received_scancode, kHandledScanCode);
61  EXPECT_EQ(last_handled, true);
62 
63  received_scancode = 0;
64 
65  handler.KeyboardHook(
66  64, kUnhandledScanCode, WM_KEYDOWN, L'b', false, false,
67  [&last_handled](bool handled) { last_handled = handled; });
68  EXPECT_EQ(received_scancode, kUnhandledScanCode);
69  EXPECT_EQ(last_handled, false);
70 
71  received_scancode = 0;
72 
73  handler.KeyboardHook(
74  64, kHandledScanCode, WM_SYSKEYDOWN, L'a', false, false,
75  [&last_handled](bool handled) { last_handled = handled; });
76  EXPECT_EQ(received_scancode, kHandledScanCode);
77  EXPECT_EQ(last_handled, true);
78 
79  received_scancode = 0;
80 
81  handler.KeyboardHook(
82  64, kUnhandledScanCode, WM_SYSKEYDOWN, L'c', false, false,
83  [&last_handled](bool handled) { last_handled = handled; });
84  EXPECT_EQ(received_scancode, kUnhandledScanCode);
85  EXPECT_EQ(last_handled, false);
86 }

References flutter::MessageCodec< T >::DecodeMessage(), flutter::JsonMessageCodec::GetInstance(), and message.

◆ TEST() [92/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
AbruptRepeatIsConvertedToDown   
)

Definition at line 777 of file keyboard_key_embedder_handler_unittests.cc.

777  {
778  TestKeystate key_state;
779  std::vector<TestFlutterKeyEvent> results;
780  TestFlutterKeyEvent* event;
781  bool last_handled = false;
782 
783  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
784  std::make_unique<KeyboardKeyEmbedderHandler>(
785  [&results](const FlutterKeyEvent& event,
786  FlutterKeyEventCallback callback, void* user_data) {
787  results.emplace_back(event, callback, user_data);
788  },
789  key_state.Getter(), DefaultMapVkToScan);
790  last_handled = false;
791 
792  key_state.Set(kVirtualKeyA, true);
793 
794  // Press A (with was_down true)
795  handler->KeyboardHook(
796  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
797  [&last_handled](bool handled) { last_handled = handled; });
798  EXPECT_EQ(last_handled, false);
799  EXPECT_EQ(results.size(), 1);
800  event = &results[0];
801  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
802  EXPECT_EQ(event->physical, kPhysicalKeyA);
803  EXPECT_EQ(event->logical, kLogicalKeyA);
804  EXPECT_STREQ(event->character, "a");
805  EXPECT_EQ(event->synthesized, false);
806 
807  event->callback(true, event->user_data);
808  EXPECT_EQ(last_handled, true);
809  results.clear();
810 
811  // Release A
812  last_handled = false;
813  key_state.Set(kVirtualKeyA, false);
814  handler->KeyboardHook(
815  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 'a', false, true,
816  [&last_handled](bool handled) { last_handled = handled; });
817  EXPECT_EQ(last_handled, false);
818  EXPECT_EQ(results.size(), 1);
819  event = &results[0];
820  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
821  EXPECT_EQ(event->physical, kPhysicalKeyA);
822  EXPECT_EQ(event->logical, kLogicalKeyA);
823  EXPECT_STREQ(event->character, "");
824  EXPECT_EQ(event->synthesized, false);
825 
826  event->callback(true, event->user_data);
827  EXPECT_EQ(last_handled, true);
828  results.clear();
829 }
user_data
void * user_data
Definition: keyboard_key_embedder_handler_unittests.cc:48
callback
FlutterKeyEventCallback callback
Definition: keyboard_key_embedder_handler_unittests.cc:47

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [93/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
AbruptUpIsIgnored   
)

Definition at line 831 of file keyboard_key_embedder_handler_unittests.cc.

831  {
832  TestKeystate key_state;
833  std::vector<TestFlutterKeyEvent> results;
834  TestFlutterKeyEvent* event;
835  bool last_handled = false;
836 
837  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
838  std::make_unique<KeyboardKeyEmbedderHandler>(
839  [&results](const FlutterKeyEvent& event,
840  FlutterKeyEventCallback callback, void* user_data) {
841  results.emplace_back(event, callback, user_data);
842  },
843  key_state.Getter(), DefaultMapVkToScan);
844  last_handled = false;
845 
846  // KeyA's key down is missed.
847 
848  key_state.Set(kVirtualKeyA, true);
849 
850  // Press A again (should yield an empty event)
851  last_handled = false;
852  handler->KeyboardHook(
853  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 'a', false, true,
854  [&last_handled](bool handled) { last_handled = handled; });
855  EXPECT_EQ(last_handled, true);
856  EXPECT_EQ(results.size(), 1);
857  event = &results[0];
858  EXPECT_EQ(event->physical, 0);
859  EXPECT_EQ(event->logical, 0);
860  EXPECT_EQ(event->callback, nullptr);
861  results.clear();
862 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [94/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
BasicKeyPressingAndHolding   
)

Definition at line 119 of file keyboard_key_embedder_handler_unittests.cc.

119  {
120  TestKeystate key_state;
121  std::vector<TestFlutterKeyEvent> results;
122  TestFlutterKeyEvent* event;
123  bool last_handled = false;
124 
125  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
126  std::make_unique<KeyboardKeyEmbedderHandler>(
127  [&results](const FlutterKeyEvent& event,
128  FlutterKeyEventCallback callback, void* user_data) {
129  results.emplace_back(event, callback, user_data);
130  },
131  key_state.Getter(), DefaultMapVkToScan);
132 
133  // Press KeyA.
134  handler->KeyboardHook(
135  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
136  [&last_handled](bool handled) { last_handled = handled; });
137  EXPECT_EQ(last_handled, false);
138  EXPECT_EQ(results.size(), 1);
139  event = &results[0];
140  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
141  EXPECT_EQ(event->physical, kPhysicalKeyA);
142  EXPECT_EQ(event->logical, kLogicalKeyA);
143  EXPECT_STREQ(event->character, "a");
144  EXPECT_EQ(event->synthesized, false);
145 
146  event->callback(true, event->user_data);
147  EXPECT_EQ(last_handled, true);
148  results.clear();
149  key_state.Set(kVirtualKeyA, true);
150 
151  // Hold KeyA.
152  handler->KeyboardHook(
153  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
154  [&last_handled](bool handled) { last_handled = handled; });
155  EXPECT_EQ(last_handled, true);
156  EXPECT_EQ(results.size(), 1);
157  event = &results[0];
158  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
159  EXPECT_EQ(event->physical, kPhysicalKeyA);
160  EXPECT_EQ(event->logical, kLogicalKeyA);
161  EXPECT_STREQ(event->character, "a");
162  EXPECT_EQ(event->synthesized, false);
163 
164  event->callback(false, event->user_data);
165  EXPECT_EQ(last_handled, false);
166  results.clear();
167 
168  // Release KeyA.
169  handler->KeyboardHook(
170  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, false, true,
171  [&last_handled](bool handled) { last_handled = handled; });
172  EXPECT_EQ(results.size(), 1);
173  event = &results[0];
174  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
175  EXPECT_EQ(event->physical, kPhysicalKeyA);
176  EXPECT_EQ(event->logical, kLogicalKeyA);
177  EXPECT_STREQ(event->character, "");
178  EXPECT_EQ(event->synthesized, false);
179  event->callback(false, event->user_data);
180 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [95/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
ConvertChar32ToUtf8   
)

Definition at line 90 of file keyboard_key_embedder_handler_unittests.cc.

90  {
91  std::string result;
92 
93  result = ConvertChar32ToUtf8(0x0024);
94  EXPECT_EQ(result.length(), 1);
95  EXPECT_EQ(result[0], '\x24');
96 
97  result = ConvertChar32ToUtf8(0x00A2);
98  EXPECT_EQ(result.length(), 2);
99  EXPECT_EQ(result[0], '\xC2');
100  EXPECT_EQ(result[1], '\xA2');
101 
102  result = ConvertChar32ToUtf8(0x0939);
103  EXPECT_EQ(result.length(), 3);
104  EXPECT_EQ(result[0], '\xE0');
105  EXPECT_EQ(result[1], '\xA4');
106  EXPECT_EQ(result[2], '\xB9');
107 
108  result = ConvertChar32ToUtf8(0x10348);
109  EXPECT_EQ(result.length(), 4);
110  EXPECT_EQ(result[0], '\xF0');
111  EXPECT_EQ(result[1], '\x90');
112  EXPECT_EQ(result[2], '\x8D');
113  EXPECT_EQ(result[3], '\x88');
114 }
flutter::ConvertChar32ToUtf8
std::string ConvertChar32ToUtf8(char32_t ch)
Definition: keyboard_key_embedder_handler.cc:38

References flutter::ConvertChar32ToUtf8().

◆ TEST() [96/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
DoNotSynthesizeModifierDownWhenPressed   
)

Definition at line 562 of file keyboard_key_embedder_handler_unittests.cc.

562  {
563  TestKeystate key_state;
564  std::vector<TestFlutterKeyEvent> results;
565  TestFlutterKeyEvent* event;
566  bool last_handled = false;
567 
568  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
569  std::make_unique<KeyboardKeyEmbedderHandler>(
570  [&results](const FlutterKeyEvent& event,
571  FlutterKeyEventCallback callback, void* user_data) {
572  results.emplace_back(event, callback, user_data);
573  },
574  key_state.Getter(), DefaultMapVkToScan);
575 
576  // Should not synthesize shift left key down event when shift left key
577  // is already pressed.
578  handler->KeyboardHook(
579  VK_LSHIFT, kScanCodeShiftLeft, WM_KEYDOWN, 0, false, true,
580  [&last_handled](bool handled) { last_handled = handled; });
581  results.clear();
582  handler->SyncModifiersIfNeeded(kShift);
583  EXPECT_EQ(results.size(), 0);
584 
585  // Should not synthesize shift left key down event when shift right key
586  // is already pressed.
587  handler->KeyboardHook(
588  VK_RSHIFT, kScanCodeShiftRight, WM_KEYDOWN, 0, false, true,
589  [&last_handled](bool handled) { last_handled = handled; });
590  results.clear();
591  handler->SyncModifiersIfNeeded(kShift);
592  EXPECT_EQ(results.size(), 0);
593 
594  // Should not synthesize control left key down event when control left key
595  // is already pressed.
596  handler->KeyboardHook(
597  VK_LCONTROL, kScanCodeControlLeft, WM_KEYDOWN, 0, false, true,
598  [&last_handled](bool handled) { last_handled = handled; });
599  results.clear();
600  handler->SyncModifiersIfNeeded(kControl);
601  EXPECT_EQ(results.size(), 0);
602 
603  // Should not synthesize control left key down event when control right key
604  // is already pressed .
605  handler->KeyboardHook(
606  VK_RCONTROL, kScanCodeControlRight, WM_KEYDOWN, 0, true, true,
607  [&last_handled](bool handled) { last_handled = handled; });
608  results.clear();
609  handler->SyncModifiersIfNeeded(kControl);
610  EXPECT_EQ(results.size(), 0);
611 }
flutter::kShift
constexpr int kShift
Definition: keyboard_utils.h:14
flutter::kScanCodeShiftRight
constexpr int kScanCodeShiftRight
Definition: keyboard_utils.h:17
flutter::kScanCodeShiftLeft
constexpr int kScanCodeShiftLeft
Definition: keyboard_utils.h:16
flutter::kScanCodeControlRight
constexpr int kScanCodeControlRight
Definition: keyboard_utils.h:20
flutter::kScanCodeControlLeft
constexpr int kScanCodeControlLeft
Definition: keyboard_utils.h:19
flutter::kControl
constexpr int kControl
Definition: keyboard_utils.h:15

References callback, flutter::kControl, flutter::kScanCodeControlLeft, flutter::kScanCodeControlRight, flutter::kScanCodeShiftLeft, flutter::kScanCodeShiftRight, flutter::kShift, and user_data.

◆ TEST() [97/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
DoNotSynthesizeModifierUpWhenNotPressed   
)

Definition at line 696 of file keyboard_key_embedder_handler_unittests.cc.

696  {
697  TestKeystate key_state;
698  std::vector<TestFlutterKeyEvent> results;
699  TestFlutterKeyEvent* event;
700  bool last_handled = false;
701 
702  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
703  std::make_unique<KeyboardKeyEmbedderHandler>(
704  [&results](const FlutterKeyEvent& event,
705  FlutterKeyEventCallback callback, void* user_data) {
706  results.emplace_back(event, callback, user_data);
707  },
708  key_state.Getter(), DefaultMapVkToScan);
709 
710  // Should not synthesize up events when no modifier key is pressed
711  // in pressing state and modifiers state is zero.
712  handler->SyncModifiersIfNeeded(0);
713  EXPECT_EQ(results.size(), 0);
714 }

References callback, and user_data.

◆ TEST() [98/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
ImeEventsAreIgnored   
)

Definition at line 259 of file keyboard_key_embedder_handler_unittests.cc.

259  {
260  TestKeystate key_state;
261  std::vector<TestFlutterKeyEvent> results;
262  TestFlutterKeyEvent* event;
263  bool last_handled = false;
264 
265  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
266  std::make_unique<KeyboardKeyEmbedderHandler>(
267  [&results](const FlutterKeyEvent& event,
268  FlutterKeyEventCallback callback, void* user_data) {
269  results.emplace_back(event, callback, user_data);
270  },
271  key_state.Getter(), DefaultMapVkToScan);
272 
273  // Press A in an IME
274  last_handled = false;
275  handler->KeyboardHook(
276  VK_PROCESSKEY, kScanCodeKeyA, WM_KEYDOWN, 0, true, false,
277  [&last_handled](bool handled) { last_handled = handled; });
278  EXPECT_EQ(last_handled, true);
279 
280  // The A key down should yield an empty event.
281  EXPECT_EQ(results.size(), 1);
282  event = &results[0];
283  EXPECT_EQ(event->physical, 0);
284  EXPECT_EQ(event->logical, 0);
285  EXPECT_EQ(event->callback, nullptr);
286  results.clear();
287 
288  // Release A in an IME
289  last_handled = false;
290  handler->KeyboardHook(
291  // The up event for an IME press has a normal virtual key.
292  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, true, true,
293  [&last_handled](bool handled) { last_handled = handled; });
294  EXPECT_EQ(last_handled, true);
295 
296  // The A key up should yield an empty event.
297  EXPECT_EQ(results.size(), 1);
298  event = &results[0];
299  EXPECT_EQ(event->physical, 0);
300  EXPECT_EQ(event->logical, 0);
301  EXPECT_EQ(event->callback, nullptr);
302  results.clear();
303 
304  // Press A out of an IME
305  key_state.Set(kVirtualKeyA, true);
306  last_handled = false;
307  handler->KeyboardHook(
308  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 0, true, false,
309  [&last_handled](bool handled) { last_handled = handled; });
310  // Not decided yet
311  EXPECT_EQ(last_handled, false);
312  EXPECT_EQ(results.size(), 1);
313  event = &results[0];
314  event->callback(true, event->user_data);
315  EXPECT_EQ(last_handled, true);
316  results.clear();
317 
318  last_handled = false;
319  key_state.Set(kVirtualKeyA, false);
320  handler->KeyboardHook(
321  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, true, false,
322  [&last_handled](bool handled) { last_handled = handled; });
323  EXPECT_EQ(last_handled, false);
324  EXPECT_EQ(results.size(), 1);
325  event = &results[0];
326  event->callback(true, event->user_data);
327  EXPECT_EQ(last_handled, true);
328 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [99/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
ModifierKeysByExtendedBit   
)

Definition at line 333 of file keyboard_key_embedder_handler_unittests.cc.

333  {
334  TestKeystate key_state;
335  std::vector<TestFlutterKeyEvent> results;
336  TestFlutterKeyEvent* event;
337  bool last_handled = false;
338 
339  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
340  std::make_unique<KeyboardKeyEmbedderHandler>(
341  [&results](const FlutterKeyEvent& event,
342  FlutterKeyEventCallback callback, void* user_data) {
343  results.emplace_back(event, callback, user_data);
344  },
345  key_state.Getter(), DefaultMapVkToScan);
346 
347  // Press Ctrl left.
348  last_handled = false;
349  key_state.Set(VK_LCONTROL, true);
350  handler->KeyboardHook(
351  VK_LCONTROL, kScanCodeControl, WM_KEYDOWN, 0, false, false,
352  [&last_handled](bool handled) { last_handled = handled; });
353  EXPECT_EQ(last_handled, false);
354  EXPECT_EQ(results.size(), 1);
355  event = &results[0];
356  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
357  EXPECT_EQ(event->physical, kPhysicalControlLeft);
358  EXPECT_EQ(event->logical, kLogicalControlLeft);
359  EXPECT_STREQ(event->character, "");
360  EXPECT_EQ(event->synthesized, false);
361 
362  event->callback(true, event->user_data);
363  EXPECT_EQ(last_handled, true);
364  results.clear();
365 
366  // Press Ctrl right.
367  last_handled = false;
368  key_state.Set(VK_RCONTROL, true);
369  handler->KeyboardHook(
370  VK_RCONTROL, kScanCodeControl, WM_KEYDOWN, 0, true, true,
371  [&last_handled](bool handled) { last_handled = handled; });
372  EXPECT_EQ(last_handled, false);
373  EXPECT_EQ(results.size(), 1);
374  event = &results[0];
375  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
376  EXPECT_EQ(event->physical, kPhysicalControlRight);
377  EXPECT_EQ(event->logical, kLogicalControlRight);
378  EXPECT_STREQ(event->character, "");
379  EXPECT_EQ(event->synthesized, false);
380 
381  event->callback(true, event->user_data);
382  EXPECT_EQ(last_handled, true);
383  results.clear();
384 
385  // Release Ctrl left.
386  last_handled = false;
387  key_state.Set(VK_LCONTROL, false);
388  handler->KeyboardHook(
389  VK_LCONTROL, kScanCodeControl, WM_KEYUP, 0, false, true,
390  [&last_handled](bool handled) { last_handled = handled; });
391  EXPECT_EQ(last_handled, false);
392  EXPECT_EQ(results.size(), 1);
393  event = &results[0];
394  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
395  EXPECT_EQ(event->physical, kPhysicalControlLeft);
396  EXPECT_EQ(event->logical, kLogicalControlLeft);
397  EXPECT_STREQ(event->character, "");
398  EXPECT_EQ(event->synthesized, false);
399 
400  event->callback(true, event->user_data);
401  EXPECT_EQ(last_handled, true);
402  results.clear();
403 
404  // Release Ctrl right.
405  last_handled = false;
406  key_state.Set(VK_RCONTROL, false);
407  handler->KeyboardHook(
408  VK_RCONTROL, kScanCodeControl, WM_KEYUP, 0, true, true,
409  [&last_handled](bool handled) { last_handled = handled; });
410  EXPECT_EQ(last_handled, false);
411  EXPECT_EQ(results.size(), 1);
412  event = &results[0];
413  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
414  EXPECT_EQ(event->physical, kPhysicalControlRight);
415  EXPECT_EQ(event->logical, kLogicalControlRight);
416  EXPECT_STREQ(event->character, "");
417  EXPECT_EQ(event->synthesized, false);
418 
419  event->callback(true, event->user_data);
420  EXPECT_EQ(last_handled, true);
421  results.clear();
422 }

References callback, and user_data.

◆ TEST() [100/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
ModifierKeysByVirtualKey   
)

Definition at line 426 of file keyboard_key_embedder_handler_unittests.cc.

426  {
427  TestKeystate key_state;
428  std::vector<TestFlutterKeyEvent> results;
429  TestFlutterKeyEvent* event;
430  bool last_handled = false;
431 
432  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
433  std::make_unique<KeyboardKeyEmbedderHandler>(
434  [&results](const FlutterKeyEvent& event,
435  FlutterKeyEventCallback callback, void* user_data) {
436  results.emplace_back(event, callback, user_data);
437  },
438  key_state.Getter(), DefaultMapVkToScan);
439 
440  // Press Shift left.
441  last_handled = false;
442  key_state.Set(VK_LSHIFT, true);
443  handler->KeyboardHook(
444  VK_LSHIFT, kScanCodeShiftLeft, WM_KEYDOWN, 0, false, false,
445  [&last_handled](bool handled) { last_handled = handled; });
446  EXPECT_EQ(last_handled, false);
447  EXPECT_EQ(results.size(), 1);
448  event = &results[0];
449  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
450  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
451  EXPECT_EQ(event->logical, kLogicalShiftLeft);
452  EXPECT_STREQ(event->character, "");
453  EXPECT_EQ(event->synthesized, false);
454 
455  event->callback(true, event->user_data);
456  EXPECT_EQ(last_handled, true);
457  results.clear();
458 
459  // Press Shift right.
460  last_handled = false;
461  key_state.Set(VK_RSHIFT, true);
462  handler->KeyboardHook(
463  VK_RSHIFT, kScanCodeShiftRight, WM_KEYDOWN, 0, false, false,
464  [&last_handled](bool handled) { last_handled = handled; });
465  EXPECT_EQ(last_handled, false);
466  EXPECT_EQ(results.size(), 1);
467  event = &results[0];
468  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
469  EXPECT_EQ(event->physical, kPhysicalShiftRight);
470  EXPECT_EQ(event->logical, kLogicalShiftRight);
471  EXPECT_STREQ(event->character, "");
472  EXPECT_EQ(event->synthesized, false);
473 
474  event->callback(true, event->user_data);
475  EXPECT_EQ(last_handled, true);
476  results.clear();
477 
478  // Release Shift left.
479  last_handled = false;
480  key_state.Set(VK_LSHIFT, false);
481  handler->KeyboardHook(
482  VK_LSHIFT, kScanCodeShiftLeft, WM_KEYUP, 0, false, true,
483  [&last_handled](bool handled) { last_handled = handled; });
484  EXPECT_EQ(last_handled, false);
485  EXPECT_EQ(results.size(), 1);
486  event = &results[0];
487  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
488  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
489  EXPECT_EQ(event->logical, kLogicalShiftLeft);
490  EXPECT_STREQ(event->character, "");
491  EXPECT_EQ(event->synthesized, false);
492 
493  event->callback(true, event->user_data);
494  EXPECT_EQ(last_handled, true);
495  results.clear();
496 
497  // Release Shift right.
498  last_handled = false;
499  key_state.Set(VK_RSHIFT, false);
500  handler->KeyboardHook(
501  VK_RSHIFT, kScanCodeShiftRight, WM_KEYUP, 0, false, true,
502  [&last_handled](bool handled) { last_handled = handled; });
503  EXPECT_EQ(last_handled, false);
504  EXPECT_EQ(results.size(), 1);
505  event = &results[0];
506  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
507  EXPECT_EQ(event->physical, kPhysicalShiftRight);
508  EXPECT_EQ(event->logical, kLogicalShiftRight);
509  EXPECT_STREQ(event->character, "");
510  EXPECT_EQ(event->synthesized, false);
511 
512  event->callback(true, event->user_data);
513  EXPECT_EQ(last_handled, true);
514  results.clear();
515 }

References callback, flutter::kScanCodeShiftLeft, flutter::kScanCodeShiftRight, and user_data.

◆ TEST() [101/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
RepeatedDownIsIgnored   
)

Definition at line 716 of file keyboard_key_embedder_handler_unittests.cc.

716  {
717  TestKeystate key_state;
718  std::vector<TestFlutterKeyEvent> results;
719  TestFlutterKeyEvent* event;
720  bool last_handled = false;
721 
722  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
723  std::make_unique<KeyboardKeyEmbedderHandler>(
724  [&results](const FlutterKeyEvent& event,
725  FlutterKeyEventCallback callback, void* user_data) {
726  results.emplace_back(event, callback, user_data);
727  },
728  key_state.Getter(), DefaultMapVkToScan);
729  last_handled = false;
730 
731  // Press A (should yield a normal event)
732  handler->KeyboardHook(
733  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
734  [&last_handled](bool handled) { last_handled = handled; });
735  EXPECT_EQ(last_handled, false);
736  EXPECT_EQ(results.size(), 1);
737  event = &results[0];
738  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
739  EXPECT_EQ(event->physical, kPhysicalKeyA);
740  EXPECT_EQ(event->logical, kLogicalKeyA);
741  EXPECT_STREQ(event->character, "a");
742  EXPECT_EQ(event->synthesized, false);
743 
744  event->callback(true, event->user_data);
745  EXPECT_EQ(last_handled, true);
746  results.clear();
747 
748  // KeyA's key up is missed.
749 
750  // Press A again (should synthesize an up event followed by a new down).
751  last_handled = false;
752  handler->KeyboardHook(
753  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
754  [&last_handled](bool handled) { last_handled = handled; });
755  EXPECT_EQ(last_handled, false);
756  ASSERT_EQ(results.size(), 2u);
757 
758  event = &results[0];
759  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
760  EXPECT_EQ(event->physical, kPhysicalKeyA);
761  EXPECT_EQ(event->logical, kLogicalKeyA);
762  EXPECT_STREQ(event->character, "");
763  EXPECT_EQ(event->synthesized, true);
764  EXPECT_EQ(event->callback, nullptr);
765 
766  event = &results[1];
767  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
768  EXPECT_EQ(event->physical, kPhysicalKeyA);
769  EXPECT_EQ(event->logical, kLogicalKeyA);
770  EXPECT_STREQ(event->character, "a");
771  EXPECT_EQ(event->synthesized, false);
772  event->callback(true, event->user_data);
773  EXPECT_EQ(last_handled, true);
774  results.clear();
775 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [102/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeForDesyncPressingState   
)

Definition at line 864 of file keyboard_key_embedder_handler_unittests.cc.

864  {
865  TestKeystate key_state;
866  std::vector<TestFlutterKeyEvent> results;
867  TestFlutterKeyEvent* event;
868  bool last_handled = false;
869 
870  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
871  std::make_unique<KeyboardKeyEmbedderHandler>(
872  [&results](const FlutterKeyEvent& event,
873  FlutterKeyEventCallback callback, void* user_data) {
874  results.emplace_back(event, callback, user_data);
875  },
876  key_state.Getter(), DefaultMapVkToScan);
877 
878  // A key down of control left is missed.
879  key_state.Set(VK_LCONTROL, true);
880 
881  // Send a normal event
882  key_state.Set(kVirtualKeyA, true);
883  handler->KeyboardHook(
884  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
885  [&last_handled](bool handled) { last_handled = handled; });
886  EXPECT_EQ(last_handled, false);
887  EXPECT_EQ(results.size(), 2);
888  event = &results[0];
889  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
890  EXPECT_EQ(event->physical, kPhysicalControlLeft);
891  EXPECT_EQ(event->logical, kLogicalControlLeft);
892  EXPECT_STREQ(event->character, "");
893  EXPECT_EQ(event->synthesized, true);
894  EXPECT_EQ(event->callback, nullptr);
895 
896  event = &results[1];
897  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
898  EXPECT_EQ(event->physical, kPhysicalKeyA);
899  EXPECT_EQ(event->logical, kLogicalKeyA);
900  EXPECT_STREQ(event->character, "a");
901  EXPECT_EQ(event->synthesized, false);
902 
903  last_handled = true;
904  event->callback(false, event->user_data);
905  EXPECT_EQ(last_handled, false);
906  results.clear();
907 
908  // A key down of control right is missed.
909  key_state.Set(VK_LCONTROL, false);
910 
911  // Hold KeyA.
912  handler->KeyboardHook(
913  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
914  [&last_handled](bool handled) { last_handled = handled; });
915  EXPECT_EQ(last_handled, false);
916  EXPECT_EQ(results.size(), 2);
917  event = &results[0];
918  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
919  EXPECT_EQ(event->physical, kPhysicalControlLeft);
920  EXPECT_EQ(event->logical, kLogicalControlLeft);
921  EXPECT_STREQ(event->character, "");
922  EXPECT_EQ(event->synthesized, true);
923  EXPECT_EQ(event->callback, nullptr);
924 
925  event = &results[1];
926  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
927  EXPECT_EQ(event->physical, kPhysicalKeyA);
928  EXPECT_EQ(event->logical, kLogicalKeyA);
929  EXPECT_STREQ(event->character, "a");
930  EXPECT_EQ(event->synthesized, false);
931 
932  last_handled = true;
933  event->callback(false, event->user_data);
934  EXPECT_EQ(last_handled, false);
935  results.clear();
936 
937  // Release KeyA.
938  key_state.Set(kVirtualKeyA, false);
939  handler->KeyboardHook(
940  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, false, true,
941  [&last_handled](bool handled) { last_handled = handled; });
942  EXPECT_EQ(results.size(), 1);
943  event = &results[0];
944  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
945  EXPECT_EQ(event->physical, kPhysicalKeyA);
946  EXPECT_EQ(event->logical, kLogicalKeyA);
947  EXPECT_STREQ(event->character, "");
948  EXPECT_EQ(event->synthesized, false);
949  event->callback(false, event->user_data);
950 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [103/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeForDesyncToggledState   
)

Definition at line 952 of file keyboard_key_embedder_handler_unittests.cc.

952  {
953  TestKeystate key_state;
954  std::vector<TestFlutterKeyEvent> results;
955  TestFlutterKeyEvent* event;
956  bool last_handled = false;
957 
958  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
959  std::make_unique<KeyboardKeyEmbedderHandler>(
960  [&results](const FlutterKeyEvent& event,
961  FlutterKeyEventCallback callback, void* user_data) {
962  results.emplace_back(event, callback, user_data);
963  },
964  key_state.Getter(), DefaultMapVkToScan);
965 
966  // The NumLock is desynchronized by toggled on
967  key_state.Set(VK_NUMLOCK, false, true);
968 
969  // Send a normal event
970  key_state.Set(kVirtualKeyA, true);
971  handler->KeyboardHook(
972  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
973  [&last_handled](bool handled) { last_handled = handled; });
974  EXPECT_EQ(last_handled, false);
975  EXPECT_EQ(results.size(), 3);
976  event = &results[0];
977  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
978  EXPECT_EQ(event->physical, kPhysicalNumLock);
979  EXPECT_EQ(event->logical, kLogicalNumLock);
980  EXPECT_STREQ(event->character, "");
981  EXPECT_EQ(event->synthesized, true);
982 
983  event = &results[1];
984  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
985  EXPECT_EQ(event->physical, kPhysicalNumLock);
986  EXPECT_EQ(event->logical, kLogicalNumLock);
987  EXPECT_STREQ(event->character, "");
988  EXPECT_EQ(event->synthesized, true);
989 
990  event = &results[2];
991  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
992  EXPECT_EQ(event->physical, kPhysicalKeyA);
993  EXPECT_EQ(event->logical, kLogicalKeyA);
994  EXPECT_STREQ(event->character, "a");
995  EXPECT_EQ(event->synthesized, false);
996 
997  event->callback(true, event->user_data);
998  EXPECT_EQ(last_handled, true);
999  results.clear();
1000 
1001  // Test if the NumLock is mis-toggled while it should also be pressed
1002  key_state.Set(VK_NUMLOCK, true, true);
1003 
1004  // Send a normal event
1005  handler->KeyboardHook(
1006  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
1007  [&last_handled](bool handled) { last_handled = handled; });
1008  EXPECT_EQ(last_handled, true);
1009  EXPECT_EQ(results.size(), 2);
1010  event = &results[0];
1011  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1012  EXPECT_EQ(event->physical, kPhysicalNumLock);
1013  EXPECT_EQ(event->logical, kLogicalNumLock);
1014  EXPECT_STREQ(event->character, "");
1015  EXPECT_EQ(event->synthesized, true);
1016 
1017  event = &results[1];
1018  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
1019  EXPECT_EQ(event->physical, kPhysicalKeyA);
1020  EXPECT_EQ(event->logical, kLogicalKeyA);
1021  EXPECT_STREQ(event->character, "a");
1022  EXPECT_EQ(event->synthesized, false);
1023 
1024  event->callback(false, event->user_data);
1025  EXPECT_EQ(last_handled, false);
1026  results.clear();
1027 
1028  // Numlock is pressed at this moment.
1029 
1030  // Test if the NumLock is mis-toggled while it should also be released
1031  key_state.Set(VK_NUMLOCK, false, false);
1032 
1033  // Send a normal event
1034  key_state.Set(kVirtualKeyA, false);
1035  handler->KeyboardHook(
1036  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, false, true,
1037  [&last_handled](bool handled) { last_handled = handled; });
1038  EXPECT_EQ(results.size(), 4);
1039  event = &results[0];
1040  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1041  EXPECT_EQ(event->physical, kPhysicalNumLock);
1042  EXPECT_EQ(event->logical, kLogicalNumLock);
1043  EXPECT_STREQ(event->character, "");
1044  EXPECT_EQ(event->synthesized, true);
1045  EXPECT_EQ(event->callback, nullptr);
1046 
1047  event = &results[1];
1048  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1049  EXPECT_EQ(event->physical, kPhysicalNumLock);
1050  EXPECT_EQ(event->logical, kLogicalNumLock);
1051  EXPECT_STREQ(event->character, "");
1052  EXPECT_EQ(event->synthesized, true);
1053  EXPECT_EQ(event->callback, nullptr);
1054 
1055  event = &results[2];
1056  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1057  EXPECT_EQ(event->physical, kPhysicalNumLock);
1058  EXPECT_EQ(event->logical, kLogicalNumLock);
1059  EXPECT_STREQ(event->character, "");
1060  EXPECT_EQ(event->synthesized, true);
1061  EXPECT_EQ(event->callback, nullptr);
1062 
1063  event = &results[3];
1064  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1065  EXPECT_EQ(event->physical, kPhysicalKeyA);
1066  EXPECT_EQ(event->logical, kLogicalKeyA);
1067  EXPECT_STREQ(event->character, "");
1068  EXPECT_EQ(event->synthesized, false);
1069  event->callback(false, event->user_data);
1070 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [104/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeForDesyncToggledStateByItselfsDown   
)

Definition at line 1132 of file keyboard_key_embedder_handler_unittests.cc.

1133  {
1134  TestKeystate key_state;
1135  std::vector<TestFlutterKeyEvent> results;
1136  TestFlutterKeyEvent* event;
1137  bool last_handled = false;
1138 
1139  // NumLock is started up and disabled
1140  key_state.Set(VK_NUMLOCK, false, false);
1141  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
1142  std::make_unique<KeyboardKeyEmbedderHandler>(
1143  [&results](const FlutterKeyEvent& event,
1144  FlutterKeyEventCallback callback, void* user_data) {
1145  results.emplace_back(event, callback, user_data);
1146  },
1147  key_state.Getter(), DefaultMapVkToScan);
1148 
1149  // NumLock is toggled somewhere else
1150  // key_state.Set(VK_NUMLOCK, false, true);
1151 
1152  // NumLock is pressed
1153  key_state.Set(VK_NUMLOCK, true, false);
1154  handler->KeyboardHook(
1155  VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
1156  [&last_handled](bool handled) { last_handled = handled; });
1157  EXPECT_EQ(last_handled, false);
1158  // 4 total events should be fired:
1159  // Pre-synchronization toggle, pre-sync press,
1160  // main event, and post-sync press.
1161  EXPECT_EQ(results.size(), 4);
1162  event = &results[0];
1163  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1164  EXPECT_EQ(event->physical, kPhysicalNumLock);
1165  EXPECT_EQ(event->logical, kLogicalNumLock);
1166  EXPECT_STREQ(event->character, "");
1167  EXPECT_EQ(event->synthesized, true);
1168  EXPECT_EQ(event->callback, nullptr);
1169 
1170  event = &results[1];
1171  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1172  EXPECT_EQ(event->physical, kPhysicalNumLock);
1173  EXPECT_EQ(event->logical, kLogicalNumLock);
1174  EXPECT_STREQ(event->character, "");
1175  EXPECT_EQ(event->synthesized, true);
1176  EXPECT_EQ(event->callback, nullptr);
1177 
1178  event = &results[2];
1179  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1180  EXPECT_EQ(event->physical, kPhysicalNumLock);
1181  EXPECT_EQ(event->logical, kLogicalNumLock);
1182  EXPECT_STREQ(event->character, "");
1183  EXPECT_EQ(event->synthesized, false);
1184 
1185  last_handled = false;
1186  event->callback(true, event->user_data);
1187  EXPECT_EQ(last_handled, true);
1188 }

References callback, and user_data.

◆ TEST() [105/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeForDesyncToggledStateByItselfsUp   
)

Definition at line 1072 of file keyboard_key_embedder_handler_unittests.cc.

1073  {
1074  TestKeystate key_state;
1075  std::vector<TestFlutterKeyEvent> results;
1076  TestFlutterKeyEvent* event;
1077  bool last_handled = false;
1078 
1079  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
1080  std::make_unique<KeyboardKeyEmbedderHandler>(
1081  [&results](const FlutterKeyEvent& event,
1082  FlutterKeyEventCallback callback, void* user_data) {
1083  results.emplace_back(event, callback, user_data);
1084  },
1085  key_state.Getter(), DefaultMapVkToScan);
1086 
1087  // When NumLock is down
1088  key_state.Set(VK_NUMLOCK, true, true);
1089  handler->KeyboardHook(
1090  VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
1091  [&last_handled](bool handled) { last_handled = handled; });
1092  event = &results.back();
1093  event->callback(false, event->user_data);
1094  results.clear();
1095 
1096  // Numlock is desynchronized by being off and released
1097  key_state.Set(VK_NUMLOCK, false, false);
1098  // Send a NumLock key up
1099  handler->KeyboardHook(
1100  VK_NUMLOCK, kScanCodeNumLock, WM_KEYUP, 0, true, true,
1101  [&last_handled](bool handled) { last_handled = handled; });
1102  EXPECT_EQ(last_handled, false);
1103  EXPECT_EQ(results.size(), 3);
1104  event = &results[0];
1105  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1106  EXPECT_EQ(event->physical, kPhysicalNumLock);
1107  EXPECT_EQ(event->logical, kLogicalNumLock);
1108  EXPECT_STREQ(event->character, "");
1109  EXPECT_EQ(event->synthesized, true);
1110  EXPECT_EQ(event->callback, nullptr);
1111 
1112  event = &results[1];
1113  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1114  EXPECT_EQ(event->physical, kPhysicalNumLock);
1115  EXPECT_EQ(event->logical, kLogicalNumLock);
1116  EXPECT_STREQ(event->character, "");
1117  EXPECT_EQ(event->synthesized, true);
1118  EXPECT_EQ(event->callback, nullptr);
1119 
1120  event = &results[2];
1121  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1122  EXPECT_EQ(event->physical, kPhysicalNumLock);
1123  EXPECT_EQ(event->logical, kLogicalNumLock);
1124  EXPECT_STREQ(event->character, "");
1125  EXPECT_EQ(event->synthesized, false);
1126 
1127  last_handled = false;
1128  event->callback(true, event->user_data);
1129  EXPECT_EQ(last_handled, true);
1130 }

References callback, and user_data.

◆ TEST() [106/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeModifierLeftKeyDownWhenNotPressed   
)

Definition at line 519 of file keyboard_key_embedder_handler_unittests.cc.

520  {
521  TestKeystate key_state;
522  std::vector<TestFlutterKeyEvent> results;
523  TestFlutterKeyEvent* event;
524  bool last_handled = false;
525 
526  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
527  std::make_unique<KeyboardKeyEmbedderHandler>(
528  [&results](const FlutterKeyEvent& event,
529  FlutterKeyEventCallback callback, void* user_data) {
530  results.emplace_back(event, callback, user_data);
531  },
532  key_state.Getter(), DefaultMapVkToScan);
533 
534  // Should synthesize shift left key down event.
535  handler->SyncModifiersIfNeeded(kShift);
536  EXPECT_EQ(results.size(), 1);
537  event = &results[0];
538  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
539  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
540  EXPECT_EQ(event->logical, kLogicalShiftLeft);
541  EXPECT_STREQ(event->character, "");
542  EXPECT_EQ(event->synthesized, true);
543  results.clear();
544 
545  // Clear the pressing state.
546  handler->SyncModifiersIfNeeded(0);
547  results.clear();
548 
549  // Should synthesize control left key down event.
550  handler->SyncModifiersIfNeeded(kControl);
551  EXPECT_EQ(results.size(), 1);
552  event = &results[0];
553  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
554  EXPECT_EQ(event->physical, kPhysicalControlLeft);
555  EXPECT_EQ(event->logical, kLogicalControlLeft);
556  EXPECT_STREQ(event->character, "");
557  EXPECT_EQ(event->synthesized, true);
558 }

References callback, flutter::kControl, flutter::kShift, and user_data.

◆ TEST() [107/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeModifierUpWhenPressed   
)

Definition at line 615 of file keyboard_key_embedder_handler_unittests.cc.

615  {
616  TestKeystate key_state;
617  std::vector<TestFlutterKeyEvent> results;
618  TestFlutterKeyEvent* event;
619  bool last_handled = false;
620 
621  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
622  std::make_unique<KeyboardKeyEmbedderHandler>(
623  [&results](const FlutterKeyEvent& event,
624  FlutterKeyEventCallback callback, void* user_data) {
625  results.emplace_back(event, callback, user_data);
626  },
627  key_state.Getter(), DefaultMapVkToScan);
628 
629  // Should synthesize shift left key up event when shift left key is
630  // already pressed and modifiers state is zero.
631  handler->KeyboardHook(
632  VK_LSHIFT, kScanCodeShiftLeft, WM_KEYDOWN, 0, false, true,
633  [&last_handled](bool handled) { last_handled = handled; });
634  results.clear();
635  handler->SyncModifiersIfNeeded(0);
636  EXPECT_EQ(results.size(), 1);
637  event = &results[0];
638  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
639  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
640  EXPECT_EQ(event->logical, kLogicalShiftLeft);
641  EXPECT_STREQ(event->character, "");
642  EXPECT_EQ(event->synthesized, true);
643  results.clear();
644 
645  // Should synthesize shift right key up event when shift right key is
646  // already pressed and modifiers state is zero.
647  handler->KeyboardHook(
648  VK_RSHIFT, kScanCodeShiftRight, WM_KEYDOWN, 0, false, true,
649  [&last_handled](bool handled) { last_handled = handled; });
650  results.clear();
651  handler->SyncModifiersIfNeeded(0);
652  EXPECT_EQ(results.size(), 1);
653  event = &results[0];
654  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
655  EXPECT_EQ(event->physical, kPhysicalShiftRight);
656  EXPECT_EQ(event->logical, kLogicalShiftRight);
657  EXPECT_STREQ(event->character, "");
658  EXPECT_EQ(event->synthesized, true);
659  results.clear();
660 
661  // Should synthesize control left key up event when control left key is
662  // already pressed and modifiers state is zero.
663  handler->KeyboardHook(
664  VK_LCONTROL, kScanCodeControlLeft, WM_KEYDOWN, 0, false, true,
665  [&last_handled](bool handled) { last_handled = handled; });
666  results.clear();
667  handler->SyncModifiersIfNeeded(0);
668  EXPECT_EQ(results.size(), 1);
669  event = &results[0];
670  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
671  EXPECT_EQ(event->physical, kPhysicalControlLeft);
672  EXPECT_EQ(event->logical, kLogicalControlLeft);
673  EXPECT_STREQ(event->character, "");
674  EXPECT_EQ(event->synthesized, true);
675  results.clear();
676 
677  // Should synthesize control right key up event when control right key is
678  // already pressed and modifiers state is zero.
679  handler->KeyboardHook(
680  VK_RCONTROL, kScanCodeControlRight, WM_KEYDOWN, 0, true, true,
681  [&last_handled](bool handled) { last_handled = handled; });
682  results.clear();
683  handler->SyncModifiersIfNeeded(0);
684  EXPECT_EQ(results.size(), 1);
685  event = &results[0];
686  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
687  EXPECT_EQ(event->physical, kPhysicalControlRight);
688  EXPECT_EQ(event->logical, kLogicalControlRight);
689  EXPECT_STREQ(event->character, "");
690  EXPECT_EQ(event->synthesized, true);
691  results.clear();
692 }

References callback, flutter::kScanCodeControlLeft, flutter::kScanCodeControlRight, flutter::kScanCodeShiftLeft, flutter::kScanCodeShiftRight, and user_data.

◆ TEST() [108/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SynthesizeWithInitialTogglingState   
)

Definition at line 1190 of file keyboard_key_embedder_handler_unittests.cc.

1190  {
1191  TestKeystate key_state;
1192  std::vector<TestFlutterKeyEvent> results;
1193  TestFlutterKeyEvent* event;
1194  bool last_handled = false;
1195 
1196  // The app starts with NumLock toggled on
1197  key_state.Set(VK_NUMLOCK, false, true);
1198 
1199  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
1200  std::make_unique<KeyboardKeyEmbedderHandler>(
1201  [&results](const FlutterKeyEvent& event,
1202  FlutterKeyEventCallback callback, void* user_data) {
1203  results.emplace_back(event, callback, user_data);
1204  },
1205  key_state.Getter(), DefaultMapVkToScan);
1206 
1207  // NumLock key down
1208  key_state.Set(VK_NUMLOCK, true, false);
1209  handler->KeyboardHook(
1210  VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
1211  [&last_handled](bool handled) { last_handled = handled; });
1212  EXPECT_EQ(last_handled, false);
1213  EXPECT_EQ(results.size(), 1);
1214  event = &results[0];
1215  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1216  EXPECT_EQ(event->physical, kPhysicalNumLock);
1217  EXPECT_EQ(event->logical, kLogicalNumLock);
1218  EXPECT_STREQ(event->character, "");
1219  EXPECT_EQ(event->synthesized, false);
1220 
1221  event->callback(true, event->user_data);
1222  EXPECT_EQ(last_handled, true);
1223  results.clear();
1224 }

References callback, and user_data.

◆ TEST() [109/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
SysKeyPress   
)

Definition at line 1226 of file keyboard_key_embedder_handler_unittests.cc.

1226  {
1227  TestKeystate key_state;
1228  std::vector<TestFlutterKeyEvent> results;
1229  TestFlutterKeyEvent* event;
1230  bool last_handled = false;
1231 
1232  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
1233  std::make_unique<KeyboardKeyEmbedderHandler>(
1234  [&results](const FlutterKeyEvent& event,
1235  FlutterKeyEventCallback callback, void* user_data) {
1236  results.emplace_back(event, callback, user_data);
1237  },
1238  key_state.Getter(), DefaultMapVkToScan);
1239 
1240  // Press KeyAltLeft.
1241  key_state.Set(VK_LMENU, true);
1242  handler->KeyboardHook(
1243  VK_LMENU, kScanCodeAltLeft, WM_SYSKEYDOWN, 0, false, false,
1244  [&last_handled](bool handled) { last_handled = handled; });
1245  EXPECT_EQ(last_handled, false);
1246  EXPECT_EQ(results.size(), 1);
1247  event = results.data();
1248  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1249  EXPECT_EQ(event->physical, kPhysicalAltLeft);
1250  EXPECT_EQ(event->logical, kLogicalAltLeft);
1251  EXPECT_STREQ(event->character, "");
1252  EXPECT_EQ(event->synthesized, false);
1253 
1254  event->callback(true, event->user_data);
1255  EXPECT_EQ(last_handled, true);
1256  results.clear();
1257 
1258  // Release KeyAltLeft.
1259  key_state.Set(VK_LMENU, false);
1260  handler->KeyboardHook(
1261  VK_LMENU, kScanCodeAltLeft, WM_SYSKEYUP, 0, false, true,
1262  [&last_handled](bool handled) { last_handled = handled; });
1263  EXPECT_EQ(results.size(), 1);
1264  event = results.data();
1265  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1266  EXPECT_EQ(event->physical, kPhysicalAltLeft);
1267  EXPECT_EQ(event->logical, kLogicalAltLeft);
1268  EXPECT_STREQ(event->character, "");
1269  EXPECT_EQ(event->synthesized, false);
1270  event->callback(false, event->user_data);
1271 }

References callback, and user_data.

◆ TEST() [110/165]

flutter::testing::TEST ( KeyboardKeyEmbedderHandlerTest  ,
ToggleNumLockDuringNumpadPress   
)

Definition at line 187 of file keyboard_key_embedder_handler_unittests.cc.

187  {
188  TestKeystate key_state;
189  std::vector<TestFlutterKeyEvent> results;
190  TestFlutterKeyEvent* event;
191  bool last_handled = false;
192 
193  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
194  std::make_unique<KeyboardKeyEmbedderHandler>(
195  [&results](const FlutterKeyEvent& event,
196  FlutterKeyEventCallback callback, void* user_data) {
197  results.emplace_back(event, callback, user_data);
198  },
199  key_state.Getter(), DefaultMapVkToScan);
200 
201  // Press NumPad1.
202  key_state.Set(VK_NUMPAD1, true);
203  handler->KeyboardHook(
204  VK_NUMPAD1, kScanCodeNumpad1, WM_KEYDOWN, 0, false, false,
205  [&last_handled](bool handled) { last_handled = handled; });
206  EXPECT_EQ(results.size(), 1);
207  event = &results[0];
208  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
209  EXPECT_EQ(event->physical, kPhysicalNumpad1);
210  EXPECT_EQ(event->logical, kLogicalNumpad1);
211  // EXPECT_STREQ(event->character, "1"); // TODO
212  EXPECT_EQ(event->synthesized, false);
213  results.clear();
214 
215  // Press NumLock.
216  key_state.Set(VK_NUMLOCK, true, true);
217  handler->KeyboardHook(
218  VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
219  [&last_handled](bool handled) { last_handled = handled; });
220  EXPECT_EQ(results.size(), 1);
221  event = &results[0];
222  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
223  EXPECT_EQ(event->physical, kPhysicalNumLock);
224  EXPECT_EQ(event->logical, kLogicalNumLock);
225  EXPECT_STREQ(event->character, "");
226  EXPECT_EQ(event->synthesized, false);
227  results.clear();
228 
229  // Release NumLock.
230  key_state.Set(VK_NUMLOCK, false, true);
231  handler->KeyboardHook(
232  VK_NUMLOCK, kScanCodeNumLock, WM_KEYUP, 0, true, true,
233  [&last_handled](bool handled) { last_handled = handled; });
234  EXPECT_EQ(results.size(), 1);
235  event = &results[0];
236  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
237  EXPECT_EQ(event->physical, kPhysicalNumLock);
238  EXPECT_EQ(event->logical, kLogicalNumLock);
239  EXPECT_STREQ(event->character, "");
240  EXPECT_EQ(event->synthesized, false);
241  results.clear();
242 
243  // Release NumPad1. (The logical key is now NumpadEnd)
244  handler->KeyboardHook(
245  VK_END, kScanCodeNumpad1, WM_KEYUP, 0, false, true,
246  [&last_handled](bool handled) { last_handled = handled; });
247  EXPECT_EQ(results.size(), 1);
248  event = &results[0];
249  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
250  EXPECT_EQ(event->physical, kPhysicalNumpad1);
251  EXPECT_EQ(event->logical, kLogicalNumpad1);
252  EXPECT_STREQ(event->character, "");
253  EXPECT_EQ(event->synthesized, false);
254  results.clear();
255 }

References callback, and user_data.

◆ TEST() [111/165]

flutter::testing::TEST ( KeyboardKeyHandlerTest  ,
HandlerGetPressedState   
)

Definition at line 311 of file keyboard_key_handler_unittests.cc.

311  {
312  TestKeystate key_state;
313 
314  TestBinaryMessenger messenger([](const std::string& channel,
315  const uint8_t* message, size_t message_size,
316  BinaryReply reply) {});
317  KeyboardKeyHandler handler(&messenger);
318 
319  std::unique_ptr<KeyboardKeyEmbedderHandler> embedder_handler =
320  std::make_unique<KeyboardKeyEmbedderHandler>(
321  [](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
322  void* user_data) {},
323  key_state.Getter(), DefaultMapVkToScan);
324  handler.AddDelegate(std::move(embedder_handler));
325 
326  // Dispatch a key event.
327  handler.KeyboardHook(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false,
328  false, OnKeyEventResult);
329 
330  std::map<uint64_t, uint64_t> pressed_state = handler.GetPressedState();
331  EXPECT_EQ(pressed_state.size(), 1);
332  EXPECT_EQ(pressed_state.at(kPhysicalKeyA), kLogicalKeyA);
333 }
user_data
void * user_data
Definition: keyboard_key_handler_unittests.cc:56
callback
FlutterKeyEventCallback callback
Definition: keyboard_key_handler_unittests.cc:55

References callback, kScanCodeKeyA, kVirtualKeyA, message, and user_data.

◆ TEST() [112/165]

flutter::testing::TEST ( KeyboardKeyHandlerTest  ,
KeyboardChannelGetPressedState   
)

Definition at line 335 of file keyboard_key_handler_unittests.cc.

335  {
336  TestKeystate key_state;
337  TestBinaryMessenger messenger;
338  KeyboardKeyHandler handler(&messenger);
339 
340  std::unique_ptr<KeyboardKeyEmbedderHandler> embedder_handler =
341  std::make_unique<KeyboardKeyEmbedderHandler>(
342  [](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
343  void* user_data) {},
344  key_state.Getter(), DefaultMapVkToScan);
345  handler.AddDelegate(std::move(embedder_handler));
346  handler.InitKeyboardChannel();
347 
348  // Dispatch a key event.
349  handler.KeyboardHook(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false,
350  false, OnKeyEventResult);
351 
352  bool success = false;
353 
354  MethodResultFunctions<> result_handler(
355  [&success](const EncodableValue* result) {
356  success = true;
357  auto& map = std::get<EncodableMap>(*result);
358  EXPECT_EQ(map.size(), 1);
359  EncodableValue physical_value(static_cast<long long>(kPhysicalKeyA));
360  EncodableValue logical_value(static_cast<long long>(kLogicalKeyA));
361  EXPECT_EQ(map.at(physical_value), logical_value);
362  },
363  nullptr, nullptr);
364 
365  SimulateKeyboardMessage(&messenger, kGetKeyboardStateMethod, nullptr,
366  &result_handler);
367  EXPECT_TRUE(success);
368 }

References flutter::KeyboardKeyHandler::AddDelegate(), callback, flutter::KeyboardKeyHandler::InitKeyboardChannel(), flutter::KeyboardKeyHandler::KeyboardHook(), kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [113/165]

flutter::testing::TEST ( KeyboardKeyHandlerTest  ,
SingleDelegateWithAsyncResponds   
)

Test 1: One event that is handled by the framework

Test 2: Two events that are unhandled by the framework

Definition at line 208 of file keyboard_key_handler_unittests.cc.

208  {
209  std::list<MockKeyHandlerDelegate::KeyboardHookCall> hook_history;
210 
211  TestBinaryMessenger messenger([](const std::string& channel,
212  const uint8_t* message, size_t message_size,
213  BinaryReply reply) {});
214  KeyboardKeyHandler handler(&messenger);
215 
216  // Add one delegate
217  auto delegate = std::make_unique<MockKeyHandlerDelegate>(1, &hook_history);
218  handler.AddDelegate(std::move(delegate));
219 
220  /// Test 1: One event that is handled by the framework
221 
222  // Dispatch a key event
223  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, true,
224  OnKeyEventResult);
225  EXPECT_EQ(key_event_response, kNoResponse);
226  EXPECT_EQ(hook_history.size(), 1);
227  EXPECT_EQ(hook_history.back().delegate_id, 1);
228  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
229  EXPECT_EQ(hook_history.back().was_down, true);
230 
231  EXPECT_EQ(key_event_response, kNoResponse);
232  hook_history.back().callback(true);
233  EXPECT_EQ(key_event_response, kHandled);
234 
235  key_event_response = kNoResponse;
236  hook_history.clear();
237 
238  /// Test 2: Two events that are unhandled by the framework
239 
240  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
241  OnKeyEventResult);
242  EXPECT_EQ(key_event_response, kNoResponse);
243  EXPECT_EQ(hook_history.size(), 1);
244  EXPECT_EQ(hook_history.back().delegate_id, 1);
245  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
246  EXPECT_EQ(hook_history.back().was_down, false);
247 
248  // Dispatch another key event
249  handler.KeyboardHook(65, kHandledScanCode2, WM_KEYUP, L'b', false, true,
250  OnKeyEventResult);
251  EXPECT_EQ(key_event_response, kNoResponse);
252  EXPECT_EQ(hook_history.size(), 2);
253  EXPECT_EQ(hook_history.back().delegate_id, 1);
254  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode2);
255  EXPECT_EQ(hook_history.back().was_down, true);
256 
257  // Resolve the second event first to test out-of-order response
258  hook_history.back().callback(false);
259  EXPECT_EQ(key_event_response, kUnhandled);
260  key_event_response = kNoResponse;
261 
262  // Resolve the first event then
263  hook_history.front().callback(false);
264  EXPECT_EQ(key_event_response, kUnhandled);
265 
266  hook_history.clear();
267  key_event_response = kNoResponse;
268 }
hook_history
std::list< KeyboardHookCall > * hook_history
Definition: keyboard_key_handler_unittests.cc:171

References hook_history, and message.

◆ TEST() [114/165]

flutter::testing::TEST ( KeyboardKeyHandlerTest  ,
SingleDelegateWithSyncResponds   
)

Test 1: One event that is handled by the framework

Test 2: An event unhandled by the framework

Definition at line 270 of file keyboard_key_handler_unittests.cc.

270  {
271  std::list<MockKeyHandlerDelegate::KeyboardHookCall> hook_history;
272 
273  TestBinaryMessenger messenger([](const std::string& channel,
274  const uint8_t* message, size_t message_size,
275  BinaryReply reply) {});
276  KeyboardKeyHandler handler(&messenger);
277  // Add one delegate
278  auto delegate = std::make_unique<MockKeyHandlerDelegate>(1, &hook_history);
279  CallbackHandler& delegate_handler = delegate->callback_handler;
280  handler.AddDelegate(std::move(delegate));
281 
282  /// Test 1: One event that is handled by the framework
283 
284  // Dispatch a key event
285  delegate_handler = respond_true;
286  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
287  OnKeyEventResult);
288  EXPECT_EQ(key_event_response, kHandled);
289  EXPECT_EQ(hook_history.size(), 1);
290  EXPECT_EQ(hook_history.back().delegate_id, 1);
291  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
292  EXPECT_EQ(hook_history.back().was_down, false);
293 
294  hook_history.clear();
295 
296  /// Test 2: An event unhandled by the framework
297 
298  delegate_handler = respond_false;
299  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
300  OnKeyEventResult);
301  EXPECT_EQ(key_event_response, kUnhandled);
302  EXPECT_EQ(hook_history.size(), 1);
303  EXPECT_EQ(hook_history.back().delegate_id, 1);
304  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
305  EXPECT_EQ(hook_history.back().was_down, false);
306 
307  hook_history.clear();
308  key_event_response = kNoResponse;
309 }

References hook_history, and message.

◆ TEST() [115/165]

flutter::testing::TEST ( KeyboardWin32CommonTest  ,
EncodeUtf16   
)

Definition at line 11 of file keyboard_utils_unittests.cc.

11  {
12  std::u16string result;
13 
14  result = EncodeUtf16(0x24);
15  EXPECT_EQ(result.size(), 1);
16  EXPECT_EQ(result[0], 0x24);
17 
18  result = EncodeUtf16(0x20AC);
19  EXPECT_EQ(result.size(), 1);
20  EXPECT_EQ(result[0], 0x20AC);
21 
22  result = EncodeUtf16(0x10437);
23  EXPECT_EQ(result.size(), 2);
24  EXPECT_EQ(result[0], 0xD801);
25  EXPECT_EQ(result[1], 0xDC37);
26 
27  result = EncodeUtf16(0x24B62);
28  EXPECT_EQ(result.size(), 2);
29  EXPECT_EQ(result[0], 0xD852);
30  EXPECT_EQ(result[1], 0xDF62);
31 }
flutter::EncodeUtf16
std::u16string EncodeUtf16(char32_t character)
Definition: keyboard_utils.cc:11

References flutter::EncodeUtf16().

◆ TEST() [116/165]

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

Definition at line 23 of file window_unittests.cc.

23  {
24  MockWindow window;
25  ASSERT_TRUE(TRUE);
26 }

◆ TEST() [117/165]

flutter::testing::TEST ( MockWindow  ,
DISABLED_GetObjectUia   
)

Definition at line 364 of file window_unittests.cc.

364  {
365  MockWindow window;
366  bool uia_called = false;
367  ON_CALL(window, OnGetObject)
368  .WillByDefault(Invoke([&uia_called](UINT msg, WPARAM wpar, LPARAM lpar) {
369 #ifdef FLUTTER_ENGINE_USE_UIA
370  uia_called = true;
371 #endif // FLUTTER_ENGINE_USE_UIA
372  return static_cast<LRESULT>(0);
373  }));
374  EXPECT_CALL(window, OnGetObject).Times(1);
375 
376  window.InjectWindowMessage(WM_GETOBJECT, 0, UiaRootObjectId);
377 
378  EXPECT_TRUE(uia_called);
379 }

◆ TEST() [118/165]

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

Definition at line 28 of file window_unittests.cc.

28  {
29  MockWindow window;
30  ASSERT_TRUE(window.GetDpi() > 0);
31 }

◆ TEST() [119/165]

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

Definition at line 152 of file window_unittests.cc.

152  {
153  MockWindow window;
154  const int scroll_amount = 10;
155  // Vertical scroll should be passed along, adjusted for scroll tick size.
156  EXPECT_CALL(window, OnScroll(scroll_amount / 120.0, 0,
157  kFlutterPointerDeviceKindMouse, 0))
158  .Times(1);
159 
160  window.InjectWindowMessage(WM_MOUSEHWHEEL, MAKEWPARAM(0, scroll_amount), 0);
161 }

◆ TEST() [120/165]

flutter::testing::TEST ( MockWindow  ,
KeyDown   
)

Definition at line 179 of file window_unittests.cc.

179  {
180  MockWindow window;
181  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
182  LPARAM lparam = CreateKeyEventLparam(42, false, false);
183  // send a "Shift" key down event.
184  window.InjectWindowMessage(WM_KEYDOWN, 16, lparam);
185 }

◆ TEST() [121/165]

flutter::testing::TEST ( MockWindow  ,
KeyDownPrintable   
)

Definition at line 211 of file window_unittests.cc.

211  {
212  MockWindow window;
213  LPARAM lparam = CreateKeyEventLparam(30, false, false);
214 
215  auto respond_false = [](int key, int scancode, int action, char32_t character,
216  bool extended, bool was_down,
217  std::function<void(bool)> callback) {
218  callback(false);
219  };
220  EXPECT_CALL(window, OnKey(65, 30, WM_KEYDOWN, 0, false, false, _))
221  .Times(1)
222  .WillOnce(respond_false);
223  EXPECT_CALL(window, OnText(_)).Times(1);
224  std::array<Win32Message, 2> messages = {
225  Win32Message{WM_KEYDOWN, 65, lparam, kWmResultDontCheck},
226  Win32Message{WM_CHAR, 65, lparam, kWmResultDontCheck}};
227  window.InjectMessageList(2, messages.data());
228 }
extended
bool extended
Definition: keyboard_key_handler_unittests.cc:118
key
int key
Definition: keyboard_key_handler_unittests.cc:114
action
int action
Definition: keyboard_key_handler_unittests.cc:116
scancode
int scancode
Definition: keyboard_key_handler_unittests.cc:115
was_down
bool was_down
Definition: keyboard_key_handler_unittests.cc:119

References action, callback, character, extended, key, scancode, and was_down.

◆ TEST() [122/165]

flutter::testing::TEST ( MockWindow  ,
KeyDownWithCtrl   
)

Definition at line 230 of file window_unittests.cc.

230  {
231  MockWindow window;
232 
233  // Simulate CONTROL pressed
234  std::array<BYTE, 256> keyboard_state;
235  keyboard_state[VK_CONTROL] = -1;
236  SetKeyboardState(keyboard_state.data());
237 
238  LPARAM lparam = CreateKeyEventLparam(30, false, false);
239 
240  // Expect OnKey, but not OnText, because Control + Key is not followed by
241  // WM_CHAR
242  EXPECT_CALL(window, OnKey(65, 30, WM_KEYDOWN, 0, false, false, _)).Times(1);
243  EXPECT_CALL(window, OnText(_)).Times(0);
244 
245  window.InjectWindowMessage(WM_KEYDOWN, 65, lparam);
246 
247  keyboard_state.fill(0);
248  SetKeyboardState(keyboard_state.data());
249 }

◆ TEST() [123/165]

flutter::testing::TEST ( MockWindow  ,
KeyDownWithCtrlToggled   
)

Definition at line 251 of file window_unittests.cc.

251  {
252  MockWindow window;
253 
254  auto respond_false = [](int key, int scancode, int action, char32_t character,
255  bool extended, bool was_down,
256  std::function<void(bool)> callback) {
257  callback(false);
258  };
259 
260  // Simulate CONTROL toggled
261  std::array<BYTE, 256> keyboard_state;
262  keyboard_state[VK_CONTROL] = 1;
263  SetKeyboardState(keyboard_state.data());
264 
265  LPARAM lparam = CreateKeyEventLparam(30, false, false);
266 
267  EXPECT_CALL(window, OnKey(65, 30, WM_KEYDOWN, 0, false, false, _))
268  .Times(1)
269  .WillOnce(respond_false);
270  EXPECT_CALL(window, OnText(_)).Times(1);
271 
272  // send a "A" key down event.
273  Win32Message messages[] = {{WM_KEYDOWN, 65, lparam, kWmResultDontCheck},
274  {WM_CHAR, 65, lparam, kWmResultDontCheck}};
275  window.InjectMessageList(2, messages);
276 
277  keyboard_state.fill(0);
278  SetKeyboardState(keyboard_state.data());
279 }

References action, callback, character, extended, key, scancode, and was_down.

◆ TEST() [124/165]

flutter::testing::TEST ( MockWindow  ,
KeyUp   
)

Definition at line 187 of file window_unittests.cc.

187  {
188  MockWindow window;
189  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
190  LPARAM lparam = CreateKeyEventLparam(42, false, true);
191  // send a "Shift" key up event.
192  window.InjectWindowMessage(WM_KEYUP, 16, lparam);
193 }

◆ TEST() [125/165]

flutter::testing::TEST ( MockWindow  ,
MouseLeave   
)

Definition at line 163 of file window_unittests.cc.

163  {
164  MockWindow window;
165  const double mouse_x = 10.0;
166  const double mouse_y = 20.0;
167 
168  EXPECT_CALL(window, OnPointerMove(mouse_x, mouse_y,
169  kFlutterPointerDeviceKindMouse, 0, 0))
170  .Times(1);
171  EXPECT_CALL(window, OnPointerLeave(mouse_x, mouse_y,
172  kFlutterPointerDeviceKindMouse, 0))
173  .Times(1);
174 
175  window.InjectWindowMessage(WM_MOUSEMOVE, 0, MAKELPARAM(mouse_x, mouse_y));
176  window.InjectWindowMessage(WM_MOUSELEAVE, 0, 0);
177 }

◆ TEST() [126/165]

flutter::testing::TEST ( MockWindow  ,
OnImeCompositionClearChange   
)

Definition at line 135 of file window_unittests.cc.

135  {
136  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
137  auto* text_input_manager = new MockTextInputManager();
138  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
139  MockWindow window(std::move(windows_proc_table),
140  std::move(text_input_manager_ptr));
141  EXPECT_CALL(window, OnComposeChange(std::u16string(u""), 0)).Times(1);
142  EXPECT_CALL(window, OnComposeCommit()).Times(1);
143  ON_CALL(window, OnImeComposition)
144  .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
145  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
146 
147  // send an IME_COMPOSITION event that contains both the result string and the
148  // composition string.
149  window.InjectWindowMessage(WM_IME_COMPOSITION, 0, 0);
150 }

◆ TEST() [127/165]

flutter::testing::TEST ( MockWindow  ,
OnImeCompositionCompose   
)

Definition at line 45 of file window_unittests.cc.

45  {
46  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
47  auto* text_input_manager = new MockTextInputManager();
48  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
49  MockWindow window(std::move(windows_proc_table),
50  std::move(text_input_manager_ptr));
51  EXPECT_CALL(*text_input_manager, GetComposingString())
52  .WillRepeatedly(
53  Return(std::optional<std::u16string>(std::u16string(u"nihao"))));
54  EXPECT_CALL(*text_input_manager, GetResultString())
55  .WillRepeatedly(
56  Return(std::optional<std::u16string>(std::u16string(u"`}"))));
57  EXPECT_CALL(*text_input_manager, GetComposingCursorPosition())
58  .WillRepeatedly(Return((int)0));
59 
60  EXPECT_CALL(window, OnComposeChange(std::u16string(u"nihao"), 0)).Times(1);
61  EXPECT_CALL(window, OnComposeChange(std::u16string(u"`}"), 0)).Times(0);
62  EXPECT_CALL(window, OnComposeCommit()).Times(0);
63  ON_CALL(window, OnImeComposition)
64  .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
65  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
66 
67  // Send an IME_COMPOSITION event that contains just the composition string.
68  window.InjectWindowMessage(WM_IME_COMPOSITION, 0, GCS_COMPSTR);
69 }

◆ TEST() [128/165]

flutter::testing::TEST ( MockWindow  ,
OnImeCompositionResult   
)

Definition at line 71 of file window_unittests.cc.

71  {
72  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
73  auto* text_input_manager = new MockTextInputManager();
74  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
75  MockWindow window(std::move(windows_proc_table),
76  std::move(text_input_manager_ptr));
77  EXPECT_CALL(*text_input_manager, GetComposingString())
78  .WillRepeatedly(
79  Return(std::optional<std::u16string>(std::u16string(u"nihao"))));
80  EXPECT_CALL(*text_input_manager, GetResultString())
81  .WillRepeatedly(
82  Return(std::optional<std::u16string>(std::u16string(u"`}"))));
83  EXPECT_CALL(*text_input_manager, GetComposingCursorPosition())
84  .WillRepeatedly(Return((int)0));
85 
86  EXPECT_CALL(window, OnComposeChange(std::u16string(u"nihao"), 0)).Times(0);
87  EXPECT_CALL(window, OnComposeChange(std::u16string(u"`}"), 0)).Times(1);
88  EXPECT_CALL(window, OnComposeCommit()).Times(1);
89  ON_CALL(window, OnImeComposition)
90  .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
91  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
92 
93  // Send an IME_COMPOSITION event that contains just the result string.
94  window.InjectWindowMessage(WM_IME_COMPOSITION, 0, GCS_RESULTSTR);
95 }

◆ TEST() [129/165]

flutter::testing::TEST ( MockWindow  ,
OnImeCompositionResultAndCompose   
)

Definition at line 97 of file window_unittests.cc.

97  {
98  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
99  auto* text_input_manager = new MockTextInputManager();
100  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
101  MockWindow window(std::move(windows_proc_table),
102  std::move(text_input_manager_ptr));
103 
104  // This situation is that Google Japanese Input finished composing "今日" in
105  // "今日は" but is still composing "は".
106  {
107  InSequence dummy;
108  EXPECT_CALL(*text_input_manager, GetResultString())
109  .WillRepeatedly(
110  Return(std::optional<std::u16string>(std::u16string(u"今日"))));
111  EXPECT_CALL(*text_input_manager, GetComposingString())
112  .WillRepeatedly(
113  Return(std::optional<std::u16string>(std::u16string(u"は"))));
114  }
115  {
116  InSequence dummy;
117  EXPECT_CALL(window, OnComposeChange(std::u16string(u"今日"), 0)).Times(1);
118  EXPECT_CALL(window, OnComposeCommit()).Times(1);
119  EXPECT_CALL(window, OnComposeChange(std::u16string(u"は"), 0)).Times(1);
120  }
121 
122  EXPECT_CALL(*text_input_manager, GetComposingCursorPosition())
123  .WillRepeatedly(Return((int)0));
124 
125  ON_CALL(window, OnImeComposition)
126  .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
127  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
128 
129  // send an IME_COMPOSITION event that contains both the result string and the
130  // composition string.
131  window.InjectWindowMessage(WM_IME_COMPOSITION, 0,
132  GCS_COMPSTR | GCS_RESULTSTR);
133 }

◆ TEST() [130/165]

flutter::testing::TEST ( MockWindow  ,
Paint   
)

Definition at line 281 of file window_unittests.cc.

281  {
282  MockWindow window;
283  EXPECT_CALL(window, OnPaint()).Times(1);
284  window.InjectWindowMessage(WM_PAINT, 0, 0);
285 }

◆ TEST() [131/165]

flutter::testing::TEST ( MockWindow  ,
PointerHitTest   
)

Definition at line 288 of file window_unittests.cc.

288  {
289  UINT32 pointer_id = 123;
290  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
291  auto text_input_manager = std::make_unique<MockTextInputManager>();
292 
293  EXPECT_CALL(*windows_proc_table, GetPointerType(Eq(pointer_id), _))
294  .Times(1)
295  .WillOnce([](UINT32 pointer_id, POINTER_INPUT_TYPE* type) {
296  *type = PT_POINTER;
297  return TRUE;
298  });
299 
300  MockWindow window(std::move(windows_proc_table),
301  std::move(text_input_manager));
302 
303  auto direct_manipulation =
304  std::make_unique<MockDirectManipulationOwner>(&window);
305 
306  EXPECT_CALL(*direct_manipulation, SetContact).Times(0);
307 
308  window.SetDirectManipulationOwner(std::move(direct_manipulation));
309  window.InjectWindowMessage(DM_POINTERHITTEST, MAKEWPARAM(pointer_id, 0), 0);
310 }
type
enum flutter::testing::@100::KeyboardChange::Type type

References type.

◆ TEST() [132/165]

flutter::testing::TEST ( MockWindow  ,
SysKeyDown   
)

Definition at line 195 of file window_unittests.cc.

195  {
196  MockWindow window;
197  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
198  LPARAM lparam = CreateKeyEventLparam(42, false, false);
199  // send a "Shift" key down event.
200  window.InjectWindowMessage(WM_SYSKEYDOWN, 16, lparam);
201 }

◆ TEST() [133/165]

flutter::testing::TEST ( MockWindow  ,
SysKeyUp   
)

Definition at line 203 of file window_unittests.cc.

203  {
204  MockWindow window;
205  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
206  LPARAM lparam = CreateKeyEventLparam(42, false, true);
207  // send a "Shift" key up event.
208  window.InjectWindowMessage(WM_SYSKEYUP, 16, lparam);
209 }

◆ TEST() [134/165]

flutter::testing::TEST ( MockWindow  ,
TouchPadHitTest   
)

Definition at line 313 of file window_unittests.cc.

313  {
314  UINT32 pointer_id = 123;
315  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
316  auto text_input_manager = std::make_unique<MockTextInputManager>();
317 
318  EXPECT_CALL(*windows_proc_table, GetPointerType(Eq(pointer_id), _))
319  .Times(1)
320  .WillOnce([](UINT32 pointer_id, POINTER_INPUT_TYPE* type) {
321  *type = PT_TOUCHPAD;
322  return TRUE;
323  });
324 
325  MockWindow window(std::move(windows_proc_table),
326  std::move(text_input_manager));
327 
328  auto direct_manipulation =
329  std::make_unique<MockDirectManipulationOwner>(&window);
330 
331  EXPECT_CALL(*direct_manipulation, SetContact(Eq(pointer_id))).Times(1);
332 
333  window.SetDirectManipulationOwner(std::move(direct_manipulation));
334  window.InjectWindowMessage(DM_POINTERHITTEST, MAKEWPARAM(pointer_id, 0), 0);
335 }

References type.

◆ TEST() [135/165]

flutter::testing::TEST ( MockWindow  ,
UnknownPointerTypeSkipsDirectManipulation   
)

Definition at line 341 of file window_unittests.cc.

341  {
342  UINT32 pointer_id = 123;
343  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
344  auto text_input_manager = std::make_unique<MockTextInputManager>();
345 
346  EXPECT_CALL(*windows_proc_table, GetPointerType(Eq(pointer_id), _))
347  .Times(1)
348  .WillOnce(
349  [](UINT32 pointer_id, POINTER_INPUT_TYPE* type) { return FALSE; });
350 
351  MockWindow window(std::move(windows_proc_table),
352  std::move(text_input_manager));
353 
354  auto direct_manipulation =
355  std::make_unique<MockDirectManipulationOwner>(&window);
356 
357  EXPECT_CALL(*direct_manipulation, SetContact).Times(0);
358 
359  window.SetDirectManipulationOwner(std::move(direct_manipulation));
360  window.InjectWindowMessage(DM_POINTERHITTEST, MAKEWPARAM(pointer_id, 0), 0);
361 }

References type.

◆ TEST() [136/165]

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

Definition at line 33 of file window_unittests.cc.

33  {
34  MockWindow window;
35  const int scroll_amount = 10;
36  // Vertical scroll should be passed along, adjusted for scroll tick size
37  // and direction.
38  EXPECT_CALL(window, OnScroll(0, -scroll_amount / 120.0,
39  kFlutterPointerDeviceKindMouse, 0))
40  .Times(1);
41 
42  window.InjectWindowMessage(WM_MOUSEWHEEL, MAKEWPARAM(0, scroll_amount), 0);
43 }

◆ TEST() [137/165]

flutter::testing::TEST ( SequentialIdGeneratorTest  ,
MaybeRemoveNumbers   
)

Definition at line 35 of file sequential_id_generator_unittests.cc.

35  {
36  const uint32_t kMinId = 0;
37  const uint32_t kMaxId = 128;
38 
39  SequentialIdGenerator generator(kMinId, kMaxId);
40 
41  EXPECT_EQ(0U, generator.GetGeneratedId(42));
42 
43  generator.ReleaseNumber(42);
44  EXPECT_FALSE(generator.HasGeneratedIdFor(42));
45  generator.ReleaseNumber(42);
46 }

References flutter::SequentialIdGenerator::GetGeneratedId(), flutter::SequentialIdGenerator::HasGeneratedIdFor(), and flutter::SequentialIdGenerator::ReleaseNumber().

◆ TEST() [138/165]

flutter::testing::TEST ( SequentialIdGeneratorTest  ,
RemoveMultipleNumbers   
)

Definition at line 12 of file sequential_id_generator_unittests.cc.

12  {
13  const uint32_t kMinId = 4;
14  const uint32_t kMaxId = 128;
15 
16  SequentialIdGenerator generator(kMinId, kMaxId);
17 
18  EXPECT_EQ(4U, generator.GetGeneratedId(45));
19  EXPECT_EQ(5U, generator.GetGeneratedId(55));
20  EXPECT_EQ(6U, generator.GetGeneratedId(15));
21 
22  generator.ReleaseNumber(45);
23  EXPECT_FALSE(generator.HasGeneratedIdFor(45));
24  generator.ReleaseNumber(15);
25  EXPECT_FALSE(generator.HasGeneratedIdFor(15));
26 
27  EXPECT_EQ(5U, generator.GetGeneratedId(55));
28  EXPECT_EQ(4U, generator.GetGeneratedId(12));
29 
30  generator.ReleaseNumber(12);
31  generator.ReleaseNumber(55);
32  EXPECT_EQ(4U, generator.GetGeneratedId(0));
33 }

References flutter::SequentialIdGenerator::GetGeneratedId(), flutter::SequentialIdGenerator::HasGeneratedIdFor(), and flutter::SequentialIdGenerator::ReleaseNumber().

◆ TEST() [139/165]

flutter::testing::TEST ( SettingsPluginTest  ,
HighContrastModeHonored   
)

Definition at line 80 of file settings_plugin_unittests.cc.

80  {
81  int times = 0;
82  TestBinaryMessenger messenger(
83  [&times](const std::string& channel, const uint8_t* message,
84  size_t message_size, BinaryReply reply) {
85  ASSERT_EQ(channel, "flutter/settings");
86  times++;
87  });
88  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
89 
90  settings_plugin.UpdateHighContrastMode(true);
91  EXPECT_TRUE(settings_plugin.is_high_contrast());
92 
93  settings_plugin.UpdateHighContrastMode(false);
94  EXPECT_FALSE(settings_plugin.is_high_contrast());
95 
96  EXPECT_EQ(times, 2);
97 }

References message.

◆ TEST() [140/165]

flutter::testing::TEST ( SettingsPluginTest  ,
SendSettingsGetsSettings   
)

Definition at line 55 of file settings_plugin_unittests.cc.

55  {
56  TestBinaryMessenger messenger([](const std::string& channel,
57  const uint8_t* message, size_t message_size,
58  BinaryReply reply) {});
59  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
60 
61  EXPECT_CALL(settings_plugin, GetAlwaysUse24HourFormat).Times(1);
62  EXPECT_CALL(settings_plugin, GetTextScaleFactor).Times(1);
63  EXPECT_CALL(settings_plugin, GetPreferredBrightness).Times(1);
64 
65  settings_plugin.SendSettings();
66 }

References message.

◆ TEST() [141/165]

flutter::testing::TEST ( SettingsPluginTest  ,
SendSettingsSendsMessage   
)

Definition at line 42 of file settings_plugin_unittests.cc.

42  {
43  bool message_is_sent = false;
44  TestBinaryMessenger messenger(
45  [&message_is_sent](const std::string& channel, const uint8_t* message,
46  size_t message_size,
47  BinaryReply reply) { message_is_sent = true; });
48  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
49 
50  settings_plugin.SendSettings();
51 
52  EXPECT_TRUE(message_is_sent);
53 }

References message.

◆ TEST() [142/165]

flutter::testing::TEST ( SettingsPluginTest  ,
StartWatchingStartsWatchingChanges   
)

Definition at line 68 of file settings_plugin_unittests.cc.

68  {
69  TestBinaryMessenger messenger([](const std::string& channel,
70  const uint8_t* message, size_t message_size,
71  BinaryReply reply) {});
72  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
73 
74  EXPECT_CALL(settings_plugin, WatchPreferredBrightnessChanged).Times(1);
75  EXPECT_CALL(settings_plugin, WatchTextScaleFactorChanged).Times(1);
76 
77  settings_plugin.StartWatching();
78 }

References message.

◆ TEST() [143/165]

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

Definition at line 16 of file system_utils_unittests.cc.

16  {
17  WindowsProcTable proc_table;
18  std::vector<LanguageInfo> languages =
19  GetPreferredLanguageInfo(WindowsProcTable());
20  // There should be at least one language.
21  ASSERT_GE(languages.size(), 1);
22  // The info should have a valid languge.
23  EXPECT_GE(languages[0].language.size(), 2);
24 }
flutter::GetPreferredLanguageInfo
std::vector< LanguageInfo > GetPreferredLanguageInfo(const WindowsProcTable &windows_proc_table)
Definition: system_utils.cc:15

References flutter::GetPreferredLanguageInfo().

◆ TEST() [144/165]

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

Definition at line 26 of file system_utils_unittests.cc.

26  {
27  MockWindowsProcTable proc_table;
28  EXPECT_CALL(proc_table, GetThreadPreferredUILanguages)
29  .WillRepeatedly(
30  [](DWORD flags, PULONG count, PZZWSTR languages, PULONG size) {
31  // Languages string ends in a double-null.
32  static const wchar_t lang[] = L"en-US\0";
33  static const size_t lang_len = sizeof(lang) / sizeof(wchar_t);
34  static const int cnt = 1;
35  if (languages == nullptr) {
36  *size = lang_len;
37  *count = cnt;
38  } else if (*size >= lang_len) {
39  memcpy(languages, lang, lang_len * sizeof(wchar_t));
40  }
41  return TRUE;
42  });
43  std::vector<std::wstring> languages = GetPreferredLanguages(proc_table);
44  // There should be at least one language.
45  ASSERT_GE(languages.size(), 1);
46  // The language should be non-empty.
47  EXPECT_FALSE(languages[0].empty());
48  // There should not be a trailing null from the parsing step.
49  EXPECT_EQ(languages[0].size(), wcslen(languages[0].c_str()));
50  EXPECT_EQ(languages[0], L"en-US");
51 }
flutter::GetPreferredLanguages
std::vector< std::wstring > GetPreferredLanguages(const WindowsProcTable &windows_proc_table)
Definition: system_utils.cc:45

References flutter::GetPreferredLanguages().

◆ TEST() [145/165]

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

Definition at line 96 of file system_utils_unittests.cc.

96  {
97  // The value varies based on machine; just ensure that something is returned.
98  EXPECT_FALSE(GetUserTimeFormat().empty());
99 }
flutter::GetUserTimeFormat
std::wstring GetUserTimeFormat()
Definition: system_utils.cc:101

References flutter::GetUserTimeFormat().

◆ TEST() [146/165]

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

Definition at line 53 of file system_utils_unittests.cc.

53  {
54  LanguageInfo info = ParseLanguageName(L"en");
55  EXPECT_EQ(info.language, "en");
56  EXPECT_TRUE(info.region.empty());
57  EXPECT_TRUE(info.script.empty());
58 }
flutter::ParseLanguageName
LanguageInfo ParseLanguageName(std::wstring language_name)
Definition: system_utils.cc:71

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

◆ TEST() [147/165]

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

Definition at line 60 of file system_utils_unittests.cc.

60  {
61  LanguageInfo info = ParseLanguageName(L"hu-HU");
62  EXPECT_EQ(info.language, "hu");
63  EXPECT_EQ(info.region, "HU");
64  EXPECT_TRUE(info.script.empty());
65 }

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

◆ TEST() [148/165]

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

Definition at line 74 of file system_utils_unittests.cc.

74  {
75  LanguageInfo info = ParseLanguageName(L"uz-Latn-UZ");
76  EXPECT_EQ(info.language, "uz");
77  EXPECT_EQ(info.region, "UZ");
78  EXPECT_EQ(info.script, "Latn");
79 }

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

◆ TEST() [149/165]

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

Definition at line 67 of file system_utils_unittests.cc.

67  {
68  LanguageInfo info = ParseLanguageName(L"us-Latn");
69  EXPECT_EQ(info.language, "us");
70  EXPECT_TRUE(info.region.empty());
71  EXPECT_EQ(info.script, "Latn");
72 }

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

◆ TEST() [150/165]

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

Definition at line 81 of file system_utils_unittests.cc.

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

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

◆ TEST() [151/165]

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

Definition at line 89 of file system_utils_unittests.cc.

89  {
90  LanguageInfo info = ParseLanguageName(L"ale-ZZ");
91  EXPECT_EQ(info.language, "ale");
92  EXPECT_EQ(info.region, "ZZ");
93  EXPECT_TRUE(info.script.empty());
94 }

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

◆ TEST() [152/165]

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

Definition at line 105 of file system_utils_unittests.cc.

105  {
106  EXPECT_FALSE(Prefer24HourTime(L"h:mm:ss tt"));
107 }
flutter::Prefer24HourTime
bool Prefer24HourTime(std::wstring time_format)
Definition: system_utils.cc:113

References flutter::Prefer24HourTime().

◆ TEST() [153/165]

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

Definition at line 109 of file system_utils_unittests.cc.

109  {
110  EXPECT_TRUE(Prefer24HourTime(L"HH:mm:ss"));
111 }

References flutter::Prefer24HourTime().

◆ TEST() [154/165]

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

Definition at line 101 of file system_utils_unittests.cc.

101  {
102  EXPECT_FALSE(Prefer24HourTime(L""));
103 }

References flutter::Prefer24HourTime().

◆ TEST() [155/165]

flutter::testing::TEST ( TaskRunnerTest  ,
MaybeExecuteTaskOnlyExpired   
)

Definition at line 72 of file task_runner_unittests.cc.

72  {
73  std::set<uint64_t> executed_task;
74  auto runner = MockTaskRunner(
75  MockGetCurrentTime, [&executed_task](const FlutterTask* expired_task) {
76  executed_task.insert(expired_task->task);
77  });
78 
79  uint64_t task_expired_before_now = 1;
80  uint64_t time_before_now = 0;
81  runner.PostFlutterTask(FlutterTask{nullptr, task_expired_before_now},
82  time_before_now);
83 
84  uint64_t task_expired_after_now = 2;
85  uint64_t time_after_now = MockGetCurrentTime() * 2;
86  runner.PostFlutterTask(FlutterTask{nullptr, task_expired_after_now},
87  time_after_now);
88 
89  runner.SimulateTimerAwake();
90 
91  std::set<uint64_t> only_task_expired_before_now{task_expired_before_now};
92  EXPECT_EQ(executed_task, only_task_expired_before_now);
93 }

◆ TEST() [156/165]

flutter::testing::TEST ( TaskRunnerTest  ,
MaybeExecuteTaskWithExactOrder   
)

Definition at line 49 of file task_runner_unittests.cc.

49  {
50  std::vector<uint64_t> executed_task_order;
51  auto runner =
52  MockTaskRunner(MockGetCurrentTime,
53  [&executed_task_order](const FlutterTask* expired_task) {
54  executed_task_order.push_back(expired_task->task);
55  });
56 
57  uint64_t time_now = MockGetCurrentTime();
58 
59  runner.PostFlutterTask(FlutterTask{nullptr, 1}, time_now);
60  runner.PostFlutterTask(FlutterTask{nullptr, 2}, time_now);
61  runner.PostTask(
62  [&executed_task_order]() { executed_task_order.push_back(3); });
63  runner.PostTask(
64  [&executed_task_order]() { executed_task_order.push_back(4); });
65 
66  runner.SimulateTimerAwake();
67 
68  std::vector<uint64_t> posted_task_order{1, 2, 3, 4};
69  EXPECT_EQ(executed_task_order, posted_task_order);
70 }

◆ TEST() [157/165]

flutter::testing::TEST ( TaskRunnerTest  ,
TaskRunnerWindowCoalescesWakeUpMessages   
)

Definition at line 124 of file task_runner_unittests.cc.

124  {
125  class Delegate : public TaskRunnerWindow::Delegate {
126  public:
127  Delegate() {}
128 
129  std::chrono::nanoseconds ProcessTasks() override {
130  process_tasks_call_count_++;
131  return std::chrono::nanoseconds::max();
132  }
133 
134  int process_tasks_call_count_ = 0;
135  };
136 
137  Delegate delegate;
138  TestTaskRunnerWindow window;
139 
140  window.AddDelegate(&delegate);
141 
142  window.WakeUp();
143  window.WakeUp();
144 
145  ::MSG msg;
146  while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
147  TranslateMessage(&msg);
148  DispatchMessage(&msg);
149  }
150 
151  EXPECT_EQ(delegate.process_tasks_call_count_, 1);
152 }

References flutter::TaskRunnerWindow::AddDelegate(), and flutter::TaskRunnerWindow::WakeUp().

◆ TEST() [158/165]

flutter::testing::TEST ( TaskRunnerTest  ,
TimerThreadDoesNotCancelEarlierScheduledTasks   
)

Definition at line 95 of file task_runner_unittests.cc.

95  {
96  std::atomic_bool signaled = false;
97  std::optional<std::chrono::high_resolution_clock::time_point> callback_time;
98  TimerThread timer_thread([&]() {
99  callback_time = std::chrono::high_resolution_clock::now();
100  signaled = true;
101  });
102  timer_thread.Start();
103  auto now = std::chrono::high_resolution_clock::now();
104  // Make sure that subsequent call to schedule does not cancel earlier task
105  // as documented in TimerThread::ScheduleAt.
106  timer_thread.ScheduleAt(now + std::chrono::milliseconds(20));
107  timer_thread.ScheduleAt(now + std::chrono::seconds(10));
108 
109  while (!signaled.load()) {
110  std::this_thread::sleep_for(std::chrono::milliseconds(5));
111  }
112 
113  EXPECT_TRUE(callback_time.has_value());
114  EXPECT_GE(*callback_time, now + std::chrono::milliseconds(20));
115 
116  timer_thread.Stop();
117 }

References flutter::TimerThread::Start().

◆ TEST() [159/165]

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

Definition at line 54 of file window_proc_delegate_manager_unittests.cc.

54  {
55  WindowProcDelegateManager manager;
56  HWND dummy_hwnd;
57 
58  bool called = false;
59  TestWindowProcDelegate delegate = [&called, &dummy_hwnd](
60  HWND hwnd, UINT message, WPARAM wparam,
61  LPARAM lparam) {
62  called = true;
63  EXPECT_EQ(hwnd, dummy_hwnd);
64  EXPECT_EQ(message, 2);
65  EXPECT_EQ(wparam, 3);
66  EXPECT_EQ(lparam, 4);
67  return std::optional<LRESULT>();
68  };
69  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback, &delegate);
70  auto result = manager.OnTopLevelWindowProc(dummy_hwnd, 2, 3, 4);
71 
72  EXPECT_TRUE(called);
73  EXPECT_FALSE(result);
74 }

References message, flutter::WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

◆ TEST() [160/165]

flutter::testing::TEST ( WindowProcDelegateManagerTest  ,
ConflictingDelegates   
)

Definition at line 163 of file window_proc_delegate_manager_unittests.cc.

163  {
164  WindowProcDelegateManager manager;
165 
166  bool called_a = false;
167  TestWindowProcDelegate delegate_a =
168  [&called_a](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
169  called_a = true;
170  return std::optional<LRESULT>(1);
171  };
172  bool called_b = false;
173  TestWindowProcDelegate delegate_b =
174  [&called_b](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
175  called_b = true;
176  return std::optional<LRESULT>(1);
177  };
178  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
179  &delegate_a);
180  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
181  &delegate_b);
182  auto result = manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
183 
184  EXPECT_TRUE(result);
185  // Exactly one of the handlers should be called since each will claim to have
186  // handled the message. Which one is unspecified, since the calling order is
187  // unspecified.
188  EXPECT_TRUE(called_a || called_b);
189  EXPECT_NE(called_a, called_b);
190 }

References message, flutter::WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

◆ TEST() [161/165]

flutter::testing::TEST ( WindowProcDelegateManagerTest  ,
Ordered   
)

Definition at line 128 of file window_proc_delegate_manager_unittests.cc.

128  {
129  TestWindowProcDelegate delegate_1 = [](HWND hwnd, UINT message, WPARAM wparam,
130  LPARAM lparam) { return 1; };
131  TestWindowProcDelegate delegate_2 = [](HWND hwnd, UINT message, WPARAM wparam,
132  LPARAM lparam) { return 2; };
133 
134  // Result should be 1 if delegate '1' is registered before delegate '2'.
135  {
136  WindowProcDelegateManager manager;
137  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
138  &delegate_1);
139  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
140  &delegate_2);
141 
142  std::optional<LRESULT> result =
143  manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
144 
145  EXPECT_EQ(result, 1);
146  }
147 
148  // Result should be 2 if delegate '2' is registered before delegate '1'.
149  {
150  WindowProcDelegateManager manager;
151  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
152  &delegate_2);
153  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
154  &delegate_1);
155 
156  std::optional<LRESULT> result =
157  manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
158 
159  EXPECT_EQ(result, 2);
160  }
161 }

References message, flutter::WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

◆ TEST() [162/165]

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

Definition at line 102 of file window_proc_delegate_manager_unittests.cc.

102  {
103  WindowProcDelegateManager manager;
104 
105  bool called_a = false;
106  TestWindowProcDelegate delegate_a =
107  [&called_a](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
108  called_a = true;
109  return std::optional<LRESULT>();
110  };
111  bool called_b = false;
112  TestWindowProcDelegate delegate_b =
113  [&called_b](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
114  called_b = true;
115  return std::optional<LRESULT>();
116  };
117  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
118  &delegate_a);
119  // Function pointer is different, so both should be called.
120  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
121  &delegate_b);
122  manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
123 
124  EXPECT_TRUE(called_a);
125  EXPECT_TRUE(called_b);
126 }

References message, flutter::WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

◆ TEST() [163/165]

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

Definition at line 76 of file window_proc_delegate_manager_unittests.cc.

76  {
77  WindowProcDelegateManager manager;
78 
79  bool called_a = false;
80  TestWindowProcDelegate delegate_a =
81  [&called_a](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
82  called_a = true;
83  return std::optional<LRESULT>();
84  };
85  bool called_b = false;
86  TestWindowProcDelegate delegate_b =
87  [&called_b](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
88  called_b = true;
89  return std::optional<LRESULT>();
90  };
91  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
92  &delegate_a);
93  // The function pointer is the same, so this should replace, not add.
94  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
95  &delegate_b);
96  manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
97 
98  EXPECT_FALSE(called_a);
99  EXPECT_TRUE(called_b);
100 }

References message, flutter::WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

◆ TEST() [164/165]

flutter::testing::TEST ( WindowProcDelegateManagerTest  ,
Unregister   
)

Definition at line 192 of file window_proc_delegate_manager_unittests.cc.

192  {
193  WindowProcDelegateManager manager;
194 
195  bool called = false;
196  TestWindowProcDelegate delegate = [&called](HWND hwnd, UINT message,
197  WPARAM wparam, LPARAM lparam) {
198  called = true;
199  return std::optional<LRESULT>();
200  };
201  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback, &delegate);
202  manager.UnregisterTopLevelWindowProcDelegate(TestWindowProcCallback);
203  auto result = manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
204 
205  EXPECT_FALSE(result);
206  EXPECT_FALSE(called);
207 }

References message, flutter::WindowProcDelegateManager::OnTopLevelWindowProc(), flutter::WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate(), and flutter::WindowProcDelegateManager::UnregisterTopLevelWindowProcDelegate().

◆ TEST() [165/165]

flutter::testing::TEST ( WindowsNoFixtureTest  ,
GetTextureRegistrar   
)

Definition at line 64 of file flutter_windows_unittests.cc.

64  {
65  FlutterDesktopEngineProperties properties = {};
66  properties.assets_path = L"";
67  properties.icu_data_path = L"icudtl.dat";
68  auto engine = FlutterDesktopEngineCreate(&properties);
69  ASSERT_NE(engine, nullptr);
70  auto texture_registrar = FlutterDesktopEngineGetTextureRegistrar(engine);
71  EXPECT_NE(texture_registrar, nullptr);
72  FlutterDesktopEngineDestroy(engine);
73 }
FlutterDesktopEngineCreate
FlutterDesktopEngineRef FlutterDesktopEngineCreate(const FlutterDesktopEngineProperties *engine_properties)
Definition: flutter_windows.cc:184
FlutterDesktopEngineDestroy
bool FlutterDesktopEngineDestroy(FlutterDesktopEngineRef engine_ref)
Definition: flutter_windows.cc:191
FlutterDesktopEngineGetTextureRegistrar
FlutterDesktopTextureRegistrarRef FlutterDesktopEngineGetTextureRegistrar(FlutterDesktopEngineRef engine)
Definition: flutter_windows.cc:240

References FlutterDesktopEngineProperties::assets_path, FlutterDesktopEngineCreate(), FlutterDesktopEngineDestroy(), FlutterDesktopEngineGetTextureRegistrar(), and FlutterDesktopEngineProperties::icu_data_path.

◆ TEST_F() [1/192]

flutter::testing::TEST_F ( AccessibilityPluginTest  ,
AnnounceWithInt32ViewId   
)

Definition at line 112 of file accessibility_plugin_unittests.cc.

112  {
113  EXPECT_CALL(*view(), AnnounceAlert(::testing::Eq(L"Hello"))).Times(1);
114 
115  SendAnnounceMessage("Hello", EncodableValue{static_cast<int32_t>(0)});
116 
117  // Verify expectations are met
118  ::testing::Mock::VerifyAndClearExpectations(view());
119 }

◆ TEST_F() [2/192]

flutter::testing::TEST_F ( AccessibilityPluginTest  ,
AnnounceWithInt64ViewId   
)

Definition at line 121 of file accessibility_plugin_unittests.cc.

121  {
122  EXPECT_CALL(*view(), AnnounceAlert(::testing::Eq(L"Hello World"))).Times(1);
123 
124  SendAnnounceMessage("Hello World", EncodableValue{static_cast<int64_t>(0)});
125 
126  // Verify expectations are met
127  ::testing::Mock::VerifyAndClearExpectations(view());
128 }

◆ TEST_F() [3/192]

flutter::testing::TEST_F ( AccessibilityPluginTest  ,
AnnounceWithInvalidViewIdType   
)

Definition at line 130 of file accessibility_plugin_unittests.cc.

130  {
131  // Should not be called with invalid viewId type
132  EXPECT_CALL(*view(), AnnounceAlert(_)).Times(0);
133 
134  SendAnnounceMessage("Hello", EncodableValue{"invalid"});
135 }

◆ TEST_F() [4/192]

flutter::testing::TEST_F ( AccessibilityPluginTest  ,
AnnounceWithMissingMessage   
)

Definition at line 136 of file accessibility_plugin_unittests.cc.

136  {
137  // Should not be called when message is missing
138  EXPECT_CALL(*view(), AnnounceAlert(_)).Times(0);
139 
140  EncodableMap data;
141  data[EncodableValue{"viewId"}] = EncodableValue{static_cast<int32_t>(0)};
142 
143  EncodableMap msg;
144  msg[EncodableValue{"type"}] = EncodableValue{"announce"};
145  msg[EncodableValue{"data"}] = EncodableValue{data};
146 
147  auto encoded =
148  StandardMessageCodec::GetInstance().EncodeMessage(EncodableValue{msg});
149 
150  messenger()->SimulateEngineMessage(
151  kAccessibilityChannelName, encoded->data(), encoded->size(),
152  [](const uint8_t* reply, size_t reply_size) {});
153 }
kAccessibilityChannelName
static constexpr char kAccessibilityChannelName[]
Definition: flutter_windows_engine.cc:36
flutter::EncodableMap
std::map< EncodableValue, EncodableValue > EncodableMap
Definition: encodable_value.h:96

References flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), and kAccessibilityChannelName.

◆ TEST_F() [5/192]

flutter::testing::TEST_F ( AccessibilityPluginTest  ,
DirectAnnounceCall   
)

Definition at line 102 of file accessibility_plugin_unittests.cc.

102  {
103  // Test calling Announce directly, bypassing the message channel
104  EXPECT_CALL(*view(), AnnounceAlert(::testing::Eq(L"Direct"))).Times(1);
105 
106  AccessibilityPlugin plugin(engine());
107  plugin.Announce(0, "Direct");
108 
109  ::testing::Mock::VerifyAndClearExpectations(view());
110 }

References flutter::AccessibilityPlugin::Announce().

◆ TEST_F() [6/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
CreateBackingStore   
)

Definition at line 140 of file compositor_opengl_unittests.cc.

140  {
141  UseHeadlessEngine();
142 
143  auto compositor =
144  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
145 
146  FlutterBackingStoreConfig config = {};
147  FlutterBackingStore backing_store = {};
148 
149  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
150  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
151  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
152 }

◆ TEST_F() [7/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
CreateBackingStoreImpeller   
)

Definition at line 154 of file compositor_opengl_unittests.cc.

154  {
155  UseHeadlessEngine();
156 
157  auto compositor =
158  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/true};
159 
160  FlutterBackingStoreConfig config = {};
161  FlutterBackingStore backing_store = {};
162 
163  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
164  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
165  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
166 }

◆ TEST_F() [8/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
InitializationFailure   
)

Definition at line 168 of file compositor_opengl_unittests.cc.

168  {
169  UseHeadlessEngine();
170 
171  auto compositor =
172  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
173 
174  FlutterBackingStoreConfig config = {};
175  FlutterBackingStore backing_store = {};
176 
177  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(false));
178  EXPECT_FALSE(compositor.CreateBackingStore(config, &backing_store));
179 }

◆ TEST_F() [9/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
InitializationRequiresBlit   
)

Definition at line 181 of file compositor_opengl_unittests.cc.

181  {
182  UseHeadlessEngine();
183 
184  const impeller::ProcTableGLES::Resolver resolver = [](const char* name) {
185  std::string function_name{name};
186 
187  if (function_name == "glBlitFramebuffer" ||
188  function_name == "glBlitFramebufferANGLE") {
189  return (void*)nullptr;
190  }
191 
192  return kMockResolver(name);
193  };
194 
195  auto compositor =
196  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/false};
197 
198  FlutterBackingStoreConfig config = {};
199  FlutterBackingStore backing_store = {};
200 
201  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
202  ASSERT_FALSE(compositor.CreateBackingStore(config, &backing_store));
203 }

◆ TEST_F() [10/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
NoSurfaceIgnored   
)

Definition at line 245 of file compositor_opengl_unittests.cc.

245  {
246  UseEngineWithView(/*add_surface = */ false);
247 
248  auto compositor =
249  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
250 
251  FlutterBackingStoreConfig config = {};
252  FlutterBackingStore backing_store = {};
253 
254  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
255  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
256 
257  FlutterLayer layer = {};
258  layer.type = kFlutterLayerContentTypeBackingStore;
259  layer.backing_store = &backing_store;
260  const FlutterLayer* layer_ptr = &layer;
261 
262  EXPECT_FALSE(compositor.Present(view(), &layer_ptr, 1));
263 
264  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
265 }

◆ TEST_F() [11/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
Present   
)

Definition at line 205 of file compositor_opengl_unittests.cc.

205  {
206  UseEngineWithView();
207 
208  auto compositor =
209  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
210 
211  FlutterBackingStoreConfig config = {};
212  FlutterBackingStore backing_store = {};
213 
214  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
215  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
216 
217  FlutterLayer layer = {};
218  layer.type = kFlutterLayerContentTypeBackingStore;
219  layer.backing_store = &backing_store;
220  const FlutterLayer* layer_ptr = &layer;
221 
222  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
223  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
224  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
225  EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
226 
227  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
228 }

◆ TEST_F() [12/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
PresentEmpty   
)

Definition at line 230 of file compositor_opengl_unittests.cc.

230  {
231  UseEngineWithView();
232 
233  auto compositor =
234  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
235 
236  // The context will be bound twice: first to initialize the compositor, second
237  // to clear the surface.
238  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
239  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
240  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
241  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
242  EXPECT_TRUE(compositor.Present(view(), nullptr, 0));
243 }

◆ TEST_F() [13/192]

flutter::testing::TEST_F ( CompositorOpenGLTest  ,
PresentUsingANGLEBlitExtension   
)

Definition at line 267 of file compositor_opengl_unittests.cc.

267  {
268  UseEngineWithView();
269 
270  bool resolved_ANGLE_blit = false;
271  const impeller::ProcTableGLES::Resolver resolver =
272  [&resolved_ANGLE_blit](const char* name) {
273  std::string function_name{name};
274 
275  if (function_name == "glBlitFramebuffer") {
276  return (void*)nullptr;
277  } else if (function_name == "glBlitFramebufferANGLE") {
278  resolved_ANGLE_blit = true;
279  return reinterpret_cast<void*>(&DoNothing);
280  }
281 
282  return kMockResolver(name);
283  };
284 
285  auto compositor =
286  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/false};
287 
288  FlutterBackingStoreConfig config = {};
289  FlutterBackingStore backing_store = {};
290 
291  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
292  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
293 
294  FlutterLayer layer = {};
295  layer.type = kFlutterLayerContentTypeBackingStore;
296  layer.backing_store = &backing_store;
297  const FlutterLayer* layer_ptr = &layer;
298 
299  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
300  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
301  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
302  EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
303  EXPECT_TRUE(resolved_ANGLE_blit);
304 
305  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
306 }

◆ TEST_F() [14/192]

flutter::testing::TEST_F ( CompositorSoftwareTest  ,
CreateBackingStore   
)

Definition at line 74 of file compositor_software_unittests.cc.

74  {
75  CompositorSoftware compositor;
76 
77  FlutterBackingStoreConfig config = {};
78  FlutterBackingStore backing_store = {};
79 
80  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
81  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
82 }

References flutter::CompositorSoftware::CollectBackingStore(), and flutter::CompositorSoftware::CreateBackingStore().

◆ TEST_F() [15/192]

flutter::testing::TEST_F ( CompositorSoftwareTest  ,
Present   
)

Definition at line 84 of file compositor_software_unittests.cc.

84  {
85  UseEngineWithView();
86 
87  CompositorSoftware compositor;
88 
89  FlutterBackingStoreConfig config = {};
90  FlutterBackingStore backing_store = {};
91 
92  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
93 
94  FlutterLayer layer = {};
95  layer.type = kFlutterLayerContentTypeBackingStore;
96  layer.backing_store = &backing_store;
97  const FlutterLayer* layer_ptr = &layer;
98 
99  EXPECT_CALL(*view(), PresentSoftwareBitmap).WillOnce(Return(true));
100  EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
101 
102  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
103 }

References flutter::CompositorSoftware::CollectBackingStore(), flutter::CompositorSoftware::CreateBackingStore(), and flutter::CompositorSoftware::Present().

◆ TEST_F() [16/192]

flutter::testing::TEST_F ( CompositorSoftwareTest  ,
PresentEmpty   
)

Definition at line 105 of file compositor_software_unittests.cc.

105  {
106  UseEngineWithView();
107 
108  CompositorSoftware compositor;
109 
110  EXPECT_CALL(*view(), ClearSoftwareBitmap).WillOnce(Return(true));
111  EXPECT_TRUE(compositor.Present(view(), nullptr, 0));
112 }

References flutter::CompositorSoftware::Present().

◆ TEST_F() [17/192]

flutter::testing::TEST_F ( CompositorSoftwareTest  ,
PresentMultiLayers   
)

Definition at line 121 of file compositor_software_unittests.cc.

121  {
122  UseEngineWithView();
123 
124  CompositorSoftware compositor;
125 
126  FlutterBackingStoreConfig config = {sizeof(config), {2, 2}};
127  FlutterBackingStore backing_store0 = {sizeof(FlutterBackingStore), nullptr};
128  FlutterBackingStore backing_store1 = {sizeof(FlutterBackingStore), nullptr};
129 
130  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store0));
131  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store1));
132 
133  uint32_t pixels0[4] = {0xff000000, 0xff0000ff, 0xff00ff00, 0xffffffff};
134  uint32_t pixels1[4] = {0x7f0000ff, 0x00ffffff, 0x7fff0000, 0xff000000};
135 
136  std::memcpy(const_cast<void*>(backing_store0.software.allocation), pixels0,
137  sizeof(uint32_t) * 4);
138  std::memcpy(const_cast<void*>(backing_store1.software.allocation), pixels1,
139  sizeof(uint32_t) * 4);
140 
141  FlutterLayer layer0 = {};
142  layer0.type = kFlutterLayerContentTypeBackingStore;
143  layer0.backing_store = &backing_store0;
144  layer0.offset = {0, 0};
145  layer0.size = {2, 2};
146 
147  FlutterLayer layer1 = layer0;
148  layer1.backing_store = &backing_store1;
149  const FlutterLayer* layer_ptr[2] = {&layer0, &layer1};
150 
151  EXPECT_CALL(*view(), PresentSoftwareBitmap)
152  .WillOnce([&](const void* allocation, size_t row_bytes, size_t height) {
153  auto pixel_data = static_cast<const uint32_t*>(allocation);
154  EXPECT_EQ(row_bytes, 2 * sizeof(uint32_t));
155  EXPECT_EQ(height, 2);
156  EXPECT_EQ(pixel_data[0], 0xff00007f);
157  EXPECT_EQ(pixel_data[1], 0xff0000ff);
158  EXPECT_EQ(pixel_data[2], 0xff7f8000);
159  EXPECT_EQ(pixel_data[3], 0xff000000);
160  return true;
161  });
162  EXPECT_TRUE(compositor.Present(view(), layer_ptr, 2));
163 
164  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store0));
165  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store1));
166 }

References flutter::CompositorSoftware::CollectBackingStore(), flutter::CompositorSoftware::CreateBackingStore(), and flutter::CompositorSoftware::Present().

◆ TEST_F() [18/192]

flutter::testing::TEST_F ( CompositorSoftwareTest  ,
PresentOffsetLayers   
)

Definition at line 171 of file compositor_software_unittests.cc.

171  {
172  UseEngineWithView();
173 
174  CompositorSoftware compositor;
175 
176  FlutterBackingStoreConfig config0 = {sizeof(FlutterBackingStoreConfig),
177  {1, 1}};
178  FlutterBackingStore backing_store0 = {sizeof(FlutterBackingStore), nullptr};
179  FlutterBackingStoreConfig config1 = {sizeof(FlutterBackingStoreConfig),
180  {2, 1}};
181  FlutterBackingStore backing_store1 = {sizeof(FlutterBackingStore), nullptr};
182 
183  ASSERT_TRUE(compositor.CreateBackingStore(config0, &backing_store0));
184  ASSERT_TRUE(compositor.CreateBackingStore(config1, &backing_store1));
185 
186  uint32_t pixels0 = 0xff0000ff;
187  uint32_t pixels1[2] = {0xffff0000, 0xffff0000};
188 
189  std::memcpy(const_cast<void*>(backing_store0.software.allocation), &pixels0,
190  sizeof(uint32_t) * 1);
191  std::memcpy(const_cast<void*>(backing_store1.software.allocation), pixels1,
192  sizeof(uint32_t) * 2);
193 
194  FlutterLayer layer0 = {};
195  layer0.type = kFlutterLayerContentTypeBackingStore;
196  layer0.backing_store = &backing_store0;
197  layer0.offset = {0, 0};
198  layer0.size = {1, 1};
199 
200  FlutterLayer layer1 = layer0;
201  layer1.backing_store = &backing_store1;
202  layer1.offset = {0, 1};
203  layer1.size = {2, 1};
204  const FlutterLayer* layer_ptr[2] = {&layer0, &layer1};
205 
206  EXPECT_CALL(*view(), PresentSoftwareBitmap)
207  .WillOnce([&](const void* allocation, size_t row_bytes, size_t height) {
208  auto pixel_data = static_cast<const uint32_t*>(allocation);
209  EXPECT_EQ(row_bytes, 2 * sizeof(uint32_t));
210  EXPECT_EQ(height, 2);
211  EXPECT_EQ(pixel_data[0], 0xff0000ff);
212  EXPECT_EQ(pixel_data[1], 0xff000000);
213  EXPECT_EQ(pixel_data[2], 0xffff0000);
214  EXPECT_EQ(pixel_data[3], 0xffff0000);
215  return true;
216  });
217  EXPECT_TRUE(compositor.Present(view(), layer_ptr, 2));
218 
219  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store0));
220  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store1));
221 }

References flutter::CompositorSoftware::CollectBackingStore(), flutter::CompositorSoftware::CreateBackingStore(), and flutter::CompositorSoftware::Present().

◆ TEST_F() [19/192]

flutter::testing::TEST_F ( CursorHandlerTest  ,
ActivateSystemCursor   
)

Definition at line 102 of file cursor_handler_unittests.cc.

102  {
103  UseEngineWithView();
104 
105  TestBinaryMessenger messenger;
106  CursorHandler cursor_handler(&messenger, engine());
107 
108  EXPECT_CALL(*proc_table(), LoadCursor(IsNull(), IDC_HAND)).Times(1);
109  EXPECT_CALL(*proc_table(), SetCursor).Times(1);
110 
111  bool success = false;
112  MethodResultFunctions<> result_handler(
113  [&success](const EncodableValue* result) {
114  success = true;
115  EXPECT_EQ(result, nullptr);
116  },
117  nullptr, nullptr);
118 
119  SimulateCursorMessage(&messenger, kActivateSystemCursorMethod,
120  std::make_unique<EncodableValue>(EncodableMap{
121  {EncodableValue("device"), EncodableValue(0)},
122  {EncodableValue("kind"), EncodableValue("click")},
123  }),
124  &result_handler);
125 
126  EXPECT_TRUE(success);
127 }
kActivateSystemCursorMethod
static constexpr char kActivateSystemCursorMethod[]
Definition: cursor_handler.cc:14

References kActivateSystemCursorMethod.

◆ TEST_F() [20/192]

flutter::testing::TEST_F ( CursorHandlerTest  ,
CreateCustomCursor   
)

Definition at line 129 of file cursor_handler_unittests.cc.

129  {
130  UseEngineWithView();
131 
132  TestBinaryMessenger messenger;
133  CursorHandler cursor_handler(&messenger, engine());
134 
135  // Create a 4x4 raw BGRA test cursor buffer.
136  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
137 
138  bool success = false;
139  MethodResultFunctions<> result_handler(
140  [&success](const EncodableValue* result) {
141  success = true;
142  EXPECT_EQ(std::get<std::string>(*result), "hello");
143  },
144  nullptr, nullptr);
145 
146  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
147  std::make_unique<EncodableValue>(EncodableMap{
148  {EncodableValue("name"), EncodableValue("hello")},
149  {EncodableValue("buffer"), EncodableValue(buffer)},
150  {EncodableValue("width"), EncodableValue(4)},
151  {EncodableValue("height"), EncodableValue(4)},
152  {EncodableValue("hotX"), EncodableValue(0.0)},
153  {EncodableValue("hotY"), EncodableValue(0.0)},
154  }),
155  &result_handler);
156 
157  EXPECT_TRUE(success);
158 }
kCreateCustomCursorMethod
static constexpr char kCreateCustomCursorMethod[]
Definition: cursor_handler.cc:19

References kCreateCustomCursorMethod.

◆ TEST_F() [21/192]

flutter::testing::TEST_F ( CursorHandlerTest  ,
DeleteCustomCursor   
)

Definition at line 231 of file cursor_handler_unittests.cc.

231  {
232  UseEngineWithView();
233 
234  TestBinaryMessenger messenger;
235  CursorHandler cursor_handler(&messenger, engine());
236 
237  // Create a 4x4 raw BGRA test cursor buffer.
238  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
239 
240  bool success = false;
241  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
242  MethodResultFunctions<> delete_result_handler(
243  [&success](const EncodableValue* result) {
244  success = true;
245  EXPECT_EQ(result, nullptr);
246  },
247  nullptr, nullptr);
248 
249  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
250  std::make_unique<EncodableValue>(EncodableMap{
251  {EncodableValue("name"), EncodableValue("hello")},
252  {EncodableValue("buffer"), EncodableValue(buffer)},
253  {EncodableValue("width"), EncodableValue(4)},
254  {EncodableValue("height"), EncodableValue(4)},
255  {EncodableValue("hotX"), EncodableValue(0.0)},
256  {EncodableValue("hotY"), EncodableValue(0.0)},
257  }),
258  &create_result_handler);
259 
260  SimulateCursorMessage(&messenger, kDeleteCustomCursorMethod,
261  std::make_unique<EncodableValue>(EncodableMap{
262  {EncodableValue("name"), EncodableValue("hello")},
263  }),
264  &delete_result_handler);
265 
266  EXPECT_TRUE(success);
267 }
kDeleteCustomCursorMethod
static constexpr char kDeleteCustomCursorMethod[]
Definition: cursor_handler.cc:41

References kCreateCustomCursorMethod, and kDeleteCustomCursorMethod.

◆ TEST_F() [22/192]

flutter::testing::TEST_F ( CursorHandlerTest  ,
DeleteNonexistentCustomCursor   
)

Definition at line 269 of file cursor_handler_unittests.cc.

269  {
270  UseEngineWithView();
271 
272  TestBinaryMessenger messenger;
273  CursorHandler cursor_handler(&messenger, engine());
274 
275  bool success = false;
276  MethodResultFunctions<> result_handler(
277  [&success](const EncodableValue* result) {
278  success = true;
279  EXPECT_EQ(result, nullptr);
280  },
281  nullptr, nullptr);
282 
283  SimulateCursorMessage(&messenger, kDeleteCustomCursorMethod,
284  std::make_unique<EncodableValue>(EncodableMap{
285  {EncodableValue("name"), EncodableValue("fake")},
286  }),
287  &result_handler);
288 
289  EXPECT_TRUE(success);
290 }

References kDeleteCustomCursorMethod.

◆ TEST_F() [23/192]

flutter::testing::TEST_F ( CursorHandlerTest  ,
SetCustomCursor   
)

Definition at line 160 of file cursor_handler_unittests.cc.

160  {
161  UseEngineWithView();
162 
163  TestBinaryMessenger messenger;
164  CursorHandler cursor_handler(&messenger, engine());
165 
166  // Create a 4x4 raw BGRA test cursor buffer.
167  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
168 
169  bool success = false;
170  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
171  MethodResultFunctions<> set_result_handler(
172  [&success](const EncodableValue* result) {
173  success = true;
174  EXPECT_EQ(result, nullptr);
175  },
176  nullptr, nullptr);
177 
178  EXPECT_CALL(*proc_table(), LoadCursor).Times(0);
179  EXPECT_CALL(*proc_table(), SetCursor(NotNull())).Times(1);
180 
181  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
182  std::make_unique<EncodableValue>(EncodableMap{
183  {EncodableValue("name"), EncodableValue("hello")},
184  {EncodableValue("buffer"), EncodableValue(buffer)},
185  {EncodableValue("width"), EncodableValue(4)},
186  {EncodableValue("height"), EncodableValue(4)},
187  {EncodableValue("hotX"), EncodableValue(0.0)},
188  {EncodableValue("hotY"), EncodableValue(0.0)},
189  }),
190  &create_result_handler);
191 
192  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
193  std::make_unique<EncodableValue>(EncodableMap{
194  {EncodableValue("name"), EncodableValue("hello")},
195  }),
196  &set_result_handler);
197 
198  EXPECT_TRUE(success);
199 }
kSetCustomCursorMethod
static constexpr char kSetCustomCursorMethod[]
Definition: cursor_handler.cc:37

References kCreateCustomCursorMethod, and kSetCustomCursorMethod.

◆ TEST_F() [24/192]

flutter::testing::TEST_F ( CursorHandlerTest  ,
SetNonexistentCustomCursor   
)

Definition at line 201 of file cursor_handler_unittests.cc.

201  {
202  UseEngineWithView();
203 
204  TestBinaryMessenger messenger;
205  CursorHandler cursor_handler(&messenger, engine());
206 
207  bool error = false;
208  MethodResultFunctions<> result_handler(
209  nullptr,
210  [&error](const std::string& error_code, const std::string& error_message,
211  const EncodableValue* value) {
212  error = true;
213  EXPECT_EQ(
214  error_message,
215  "The custom cursor identified by the argument key cannot be found");
216  },
217  nullptr);
218 
219  EXPECT_CALL(*proc_table(), LoadCursor).Times(0);
220  EXPECT_CALL(*proc_table(), SetCursor).Times(0);
221 
222  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
223  std::make_unique<EncodableValue>(EncodableMap{
224  {EncodableValue("name"), EncodableValue("hello")},
225  }),
226  &result_handler);
227 
228  EXPECT_TRUE(error);
229 }

References kSetCustomCursorMethod.

◆ TEST_F() [25/192]

flutter::testing::TEST_F ( DisplayManagerWin32Test  ,
HandleDisplayChangeMessage   
)

Definition at line 89 of file display_manager_unittests.cc.

89  {
90  // Create a mock Windows proc table
91  auto mock_windows_proc_table =
92  std::make_shared<NiceMock<MockWindowsProcTable>>();
93 
94  // Create a mock engine
95  FlutterWindowsEngineBuilder builder(GetContext());
96  builder.SetWindowsProcTable(mock_windows_proc_table);
97  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
98 
99  EXPECT_CALL(*mock_windows_proc_table, EnumDisplayMonitors(_, _, _, _))
100  .WillRepeatedly(Return(TRUE));
101 
102  // Create the display manager with the mock engine
103  auto display_manager = std::make_unique<DisplayManagerWin32>(engine.get());
104 
105  // Test handling a display change message
106  HWND dummy_hwnd = reinterpret_cast<HWND>(1);
107  LRESULT result = 0;
108 
109  // Verify that WM_DISPLAYCHANGE is handled
110  EXPECT_FALSE(display_manager->HandleWindowMessage(
111  dummy_hwnd, WM_DISPLAYCHANGE, 0, 0, &result));
112 
113  // Verify that WM_DPICHANGED is handled
114  EXPECT_FALSE(display_manager->HandleWindowMessage(dummy_hwnd, WM_DPICHANGED,
115  0, 0, &result));
116 
117  // Verify that other messages are not handled
118  EXPECT_FALSE(display_manager->HandleWindowMessage(dummy_hwnd, WM_PAINT, 0, 0,
119  &result));
120 }
display_manager
const DisplayManagerWin32 * display_manager
Definition: display_manager.cc:18

References display_manager.

◆ TEST_F() [26/192]

flutter::testing::TEST_F ( DisplayManagerWin32Test  ,
MultipleMonitors   
)

Definition at line 34 of file display_manager_unittests.cc.

34  {
35  auto mock_windows_proc_table =
36  std::make_shared<NiceMock<MockWindowsProcTable>>();
37 
38  FlutterWindowsEngineBuilder builder(GetContext());
39  builder.SetWindowsProcTable(mock_windows_proc_table);
40  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
41 
42  HMONITOR mock_monitor1 = reinterpret_cast<HMONITOR>(123);
43  HMONITOR mock_monitor2 = reinterpret_cast<HMONITOR>(456);
44 
45  MONITORINFOEXW monitor_info1 = {};
46  monitor_info1.cbSize = sizeof(MONITORINFOEXW);
47  monitor_info1.rcMonitor = {0, 0, 1920, 1080};
48  monitor_info1.rcWork = {0, 0, 1920, 1080};
49  monitor_info1.dwFlags = MONITORINFOF_PRIMARY;
50  wcscpy_s(monitor_info1.szDevice, L"\\\\.\\DISPLAY1");
51 
52  MONITORINFOEXW monitor_info2 = {};
53  monitor_info2.cbSize = sizeof(MONITORINFOEXW);
54  monitor_info2.rcMonitor = {1920, 0, 1920 + 2560, 1440};
55  monitor_info2.rcWork = {1920, 0, 1920 + 2560, 1440};
56  monitor_info2.dwFlags = 0;
57  wcscpy_s(monitor_info2.szDevice, L"\\\\.\\DISPLAY2");
58 
59  EXPECT_CALL(*mock_windows_proc_table, GetMonitorInfoW(mock_monitor1, _))
60  .WillOnce(DoAll(SetArgPointee<1>(monitor_info1), Return(TRUE)));
61  EXPECT_CALL(*mock_windows_proc_table, GetMonitorInfoW(mock_monitor2, _))
62  .WillOnce(DoAll(SetArgPointee<1>(monitor_info2), Return(TRUE)));
63 
64  EXPECT_CALL(*mock_windows_proc_table,
65  EnumDisplayMonitors(nullptr, nullptr, _, _))
66  .WillOnce([&](HDC hdc, LPCRECT lprcClip, MONITORENUMPROC lpfnEnum,
67  LPARAM dwData) {
68  lpfnEnum(mock_monitor1, nullptr, &monitor_info1.rcMonitor, dwData);
69  lpfnEnum(mock_monitor2, nullptr, &monitor_info2.rcMonitor, dwData);
70  return TRUE;
71  });
72 
73  // Set up GetDpiForMonitor to return different DPI values
74  EXPECT_CALL(*mock_windows_proc_table, GetDpiForMonitor(mock_monitor1, _))
75  .WillRepeatedly(Return(96)); // Default/Standard DPI
76  EXPECT_CALL(*mock_windows_proc_table, GetDpiForMonitor(mock_monitor2, _))
77  .WillRepeatedly(Return(144)); // High DPI
78 
79  EXPECT_CALL(*mock_windows_proc_table, EnumDisplaySettings(_, _, _))
80  .WillRepeatedly(Return(TRUE));
81 
82  // Create the display manager with the mock engine
83  auto display_manager = std::make_unique<DisplayManagerWin32>(engine.get());
84 
85  display_manager->UpdateDisplays();
86 }

References display_manager, and flutter::GetDpiForMonitor().

◆ TEST_F() [27/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
AccessibilityAnnouncement   
)

Definition at line 791 of file flutter_windows_engine_unittests.cc.

791  {
792  auto& context = GetContext();
793  WindowsConfigBuilder builder{context};
794  builder.SetDartEntrypoint("sendAccessibilityAnnouncement");
795 
796  bool done = false;
797  auto native_entry =
798  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
799  context.AddNativeFunction("Signal", native_entry);
800 
801  EnginePtr engine{builder.RunHeadless()};
802  ASSERT_NE(engine, nullptr);
803 
804  ui::AXPlatformNodeDelegateBase parent_delegate;
805  AlertPlatformNodeDelegate delegate{parent_delegate};
806 
807  auto window_binding_handler =
808  std::make_unique<NiceMock<MockWindowBindingHandler>>();
809  EXPECT_CALL(*window_binding_handler, GetAlertDelegate)
810  .WillOnce(Return(&delegate));
811 
812  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
813  MockFlutterWindowsView view{windows_engine,
814  std::move(window_binding_handler)};
815  EngineModifier modifier{windows_engine};
816  modifier.SetImplicitView(&view);
817 
818  windows_engine->UpdateSemanticsEnabled(true);
819 
820  EXPECT_CALL(view, NotifyWinEventWrapper).Times(1);
821 
822  // Rely on timeout mechanism in CI.
823  while (!done) {
824  windows_engine->task_runner()->ProcessTasks();
825  }
826 }

References flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [28/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
AccessibilityAnnouncementHeadless   
)

Definition at line 829 of file flutter_windows_engine_unittests.cc.

829  {
830  auto& context = GetContext();
831  WindowsConfigBuilder builder{context};
832  builder.SetDartEntrypoint("sendAccessibilityAnnouncement");
833 
834  bool done = false;
835  auto native_entry =
836  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
837  context.AddNativeFunction("Signal", native_entry);
838 
839  EnginePtr engine{builder.RunHeadless()};
840  ASSERT_NE(engine, nullptr);
841 
842  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
843  windows_engine->UpdateSemanticsEnabled(true);
844 
845  // Rely on timeout mechanism in CI.
846  while (!done) {
847  windows_engine->task_runner()->ProcessTasks();
848  }
849 }

References flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [29/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
AccessibilityTooltip   
)

Definition at line 853 of file flutter_windows_engine_unittests.cc.

853  {
854  fml::testing::LogCapture log_capture;
855 
856  auto& context = GetContext();
857  WindowsConfigBuilder builder{context};
858  builder.SetDartEntrypoint("sendAccessibilityTooltipEvent");
859 
860  bool done = false;
861  auto native_entry =
862  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
863  context.AddNativeFunction("Signal", native_entry);
864 
865  ViewControllerPtr controller{builder.Run()};
866  ASSERT_NE(controller, nullptr);
867 
868  auto engine = FlutterDesktopViewControllerGetEngine(controller.get());
869  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine);
870  windows_engine->UpdateSemanticsEnabled(true);
871 
872  // Rely on timeout mechanism in CI.
873  while (!done) {
874  windows_engine->task_runner()->ProcessTasks();
875  }
876 
877  // Verify no error was logged.
878  // Regression test for:
879  // https://github.com/flutter/flutter/issues/144274
880  EXPECT_EQ(log_capture.str().find("tooltip"), std::string::npos);
881 }
FlutterDesktopViewControllerGetEngine
FlutterDesktopEngineRef FlutterDesktopViewControllerGetEngine(FlutterDesktopViewControllerRef ref)
Definition: flutter_windows.cc:148

References FlutterDesktopViewControllerGetEngine(), and flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [30/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
AddPluginRegistrarDestructionCallback   
)

Definition at line 639 of file flutter_windows_engine_unittests.cc.

639  {
640  FlutterWindowsEngineBuilder builder{GetContext()};
641  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
642  EngineModifier modifier(engine.get());
643 
644  MockEmbedderApiForKeyboard(modifier,
645  std::make_shared<MockKeyResponseController>());
646 
647  engine->Run();
648 
649  // Verify that destruction handlers don't overwrite each other.
650  int result1 = 0;
651  int result2 = 0;
652  engine->AddPluginRegistrarDestructionCallback(
653  [](FlutterDesktopPluginRegistrarRef ref) {
654  auto result = reinterpret_cast<int*>(ref);
655  *result = 1;
656  },
657  reinterpret_cast<FlutterDesktopPluginRegistrarRef>(&result1));
658  engine->AddPluginRegistrarDestructionCallback(
659  [](FlutterDesktopPluginRegistrarRef ref) {
660  auto result = reinterpret_cast<int*>(ref);
661  *result = 2;
662  },
663  reinterpret_cast<FlutterDesktopPluginRegistrarRef>(&result2));
664 
665  engine->Stop();
666  EXPECT_EQ(result1, 1);
667  EXPECT_EQ(result2, 2);
668 }

◆ TEST_F() [31/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
AddViewFailureDoesNotHang   
)

Definition at line 1416 of file flutter_windows_engine_unittests.cc.

1416  {
1417  FlutterWindowsEngineBuilder builder{GetContext()};
1418  auto engine = builder.Build();
1419 
1420  EngineModifier modifier{engine.get()};
1421 
1422  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1423  modifier.embedder_api().AddView = MOCK_ENGINE_PROC(
1424  AddView,
1425  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
1426  const FlutterAddViewInfo* info) { return kInternalInconsistency; });
1427 
1428  ASSERT_TRUE(engine->Run());
1429 
1430  // Create the first view. This is the implicit view and isn't added to the
1431  // engine.
1432  auto implicit_window = std::make_unique<NiceMock<MockWindowBindingHandler>>();
1433 
1434  std::unique_ptr<FlutterWindowsView> implicit_view =
1435  engine->CreateView(std::move(implicit_window),
1436  /*is_sized_to_content=*/false, BoxConstraints());
1437 
1438  EXPECT_TRUE(implicit_view);
1439 
1440  // Create a second view. The embedder attempts to add it to the engine.
1441  auto second_window = std::make_unique<NiceMock<MockWindowBindingHandler>>();
1442 
1443  EXPECT_DEBUG_DEATH(
1444  engine->CreateView(std::move(second_window),
1445  /*is_sized_to_content=*/false, BoxConstraints()),
1446  "FlutterEngineAddView returned an unexpected result");
1447 }

References flutter::FlutterEngine::Run().

◆ TEST_F() [32/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
ApplicationLifecycleExternalWindow   
)

Definition at line 1122 of file flutter_windows_engine_unittests.cc.

1122  {
1123  FlutterWindowsEngineBuilder builder{GetContext()};
1124 
1125  auto engine = builder.Build();
1126  auto window_binding_handler =
1127  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1128  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1129 
1130  EngineModifier modifier(engine.get());
1131  modifier.SetImplicitView(&view);
1132  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1133  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1134  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(false));
1135  modifier.SetLifecycleManager(std::move(handler));
1136  engine->lifecycle_manager()->BeginProcessingExit();
1137 
1138  engine->lifecycle_manager()->ExternalWindowMessage(0, WM_CLOSE, 0, 0);
1139 }

◆ TEST_F() [33/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
ChannelListenedTo   
)

Definition at line 1366 of file flutter_windows_engine_unittests.cc.

1366  {
1367  FlutterWindowsEngineBuilder builder{GetContext()};
1368  builder.SetDartEntrypoint("enableLifecycleToFrom");
1369 
1370  auto engine = builder.Build();
1371  auto window_binding_handler =
1372  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1373  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1374 
1375  EngineModifier modifier(engine.get());
1376  modifier.SetImplicitView(&view);
1377  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1378 
1379  bool lifecycle_began = false;
1380  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1381  handler->begin_processing_callback = [&]() { lifecycle_began = true; };
1382  modifier.SetLifecycleManager(std::move(handler));
1383 
1384  engine->Run();
1385 
1386  while (!lifecycle_began) {
1387  engine->task_runner()->ProcessTasks();
1388  }
1389 }

◆ TEST_F() [34/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
ConfiguresFrameVsync   
)

Definition at line 297 of file flutter_windows_engine_unittests.cc.

297  {
298  FlutterWindowsEngineBuilder builder{GetContext()};
299  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
300  EngineModifier modifier(engine.get());
301  bool on_vsync_called = false;
302 
303  modifier.embedder_api().GetCurrentTime =
304  MOCK_ENGINE_PROC(GetCurrentTime, ([]() -> uint64_t { return 1; }));
305  modifier.embedder_api().OnVsync = MOCK_ENGINE_PROC(
306  OnVsync,
307  ([&on_vsync_called, engine_instance = engine.get()](
308  FLUTTER_API_SYMBOL(FlutterEngine) engine, intptr_t baton,
309  uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos) {
310  EXPECT_EQ(baton, 1);
311  EXPECT_EQ(frame_start_time_nanos, 16600000);
312  EXPECT_EQ(frame_target_time_nanos, 33200000);
313  on_vsync_called = true;
314  return kSuccess;
315  }));
316  modifier.SetStartTime(0);
317  modifier.SetFrameInterval(16600000);
318 
319  engine->OnVsync(1);
320 
321  EXPECT_TRUE(on_vsync_called);
322 }

◆ TEST_F() [35/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
DispatchSemanticsAction   
)

Definition at line 594 of file flutter_windows_engine_unittests.cc.

594  {
595  FlutterWindowsEngineBuilder builder{GetContext()};
596  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
597  EngineModifier modifier(engine.get());
598 
599  bool called = false;
600  std::string message = "Hello";
601  modifier.embedder_api().SendSemanticsAction = MOCK_ENGINE_PROC(
602  SendSemanticsAction, ([&called, &message](auto engine, auto info) {
603  called = true;
604  EXPECT_EQ(info->view_id, 456);
605  EXPECT_EQ(info->node_id, 42);
606  EXPECT_EQ(info->action, kFlutterSemanticsActionDismiss);
607  EXPECT_EQ(memcmp(info->data, message.c_str(), message.size()), 0);
608  EXPECT_EQ(info->data_length, message.size());
609  return kSuccess;
610  }));
611 
612  auto data = fml::MallocMapping::Copy(message.c_str(), message.size());
613  engine->DispatchSemanticsAction(456, 42, kFlutterSemanticsActionDismiss,
614  std::move(data));
615  EXPECT_TRUE(called);
616 }

References message.

◆ TEST_F() [36/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
EnableApplicationLifecycle   
)

Definition at line 1102 of file flutter_windows_engine_unittests.cc.

1102  {
1103  FlutterWindowsEngineBuilder builder{GetContext()};
1104 
1105  auto engine = builder.Build();
1106  auto window_binding_handler =
1107  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1108  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1109 
1110  EngineModifier modifier(engine.get());
1111  modifier.SetImplicitView(&view);
1112  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1113  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1114  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(false));
1115  modifier.SetLifecycleManager(std::move(handler));
1116  engine->lifecycle_manager()->BeginProcessingExit();
1117 
1118  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
1119  0);
1120 }

◆ TEST_F() [37/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
EnableLifecycleState   
)

Definition at line 1265 of file flutter_windows_engine_unittests.cc.

1265  {
1266  FlutterWindowsEngineBuilder builder{GetContext()};
1267  builder.SetDartEntrypoint("enableLifecycleTest");
1268  bool finished = false;
1269 
1270  auto engine = builder.Build();
1271  auto window_binding_handler =
1272  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1273  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1274 
1275  EngineModifier modifier(engine.get());
1276  modifier.SetImplicitView(&view);
1277  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1278  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1279  EXPECT_CALL(*handler, SetLifecycleState)
1280  .WillRepeatedly([handler_ptr = handler.get()](AppLifecycleState state) {
1281  handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1282  });
1283  modifier.SetLifecycleManager(std::move(handler));
1284 
1285  auto binary_messenger =
1286  std::make_unique<BinaryMessengerImpl>(engine->messenger());
1287  // Mark the test only as completed on receiving an inactive state message.
1288  binary_messenger->SetMessageHandler(
1289  "flutter/unittest", [&finished](const uint8_t* message,
1290  size_t message_size, BinaryReply reply) {
1291  std::string contents(message, message + message_size);
1292  EXPECT_NE(contents.find("AppLifecycleState.inactive"),
1293  std::string::npos);
1294  finished = true;
1295  char response[] = "";
1296  reply(reinterpret_cast<uint8_t*>(response), 0);
1297  });
1298 
1299  engine->Run();
1300 
1301  // Test that setting the state before enabling lifecycle does nothing.
1302  HWND hwnd = reinterpret_cast<HWND>(1);
1303  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
1304  view.OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
1305  EXPECT_FALSE(finished);
1306 
1307  // Test that we can set the state afterwards.
1308 
1309  engine->lifecycle_manager()->BeginProcessingLifecycle();
1310  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
1311 
1312  while (!finished) {
1313  engine->task_runner()->ProcessTasks();
1314  }
1315 }

References flutter::kHide, flutter::kShow, and message.

◆ TEST_F() [38/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
ExternalWindowMessage   
)

Definition at line 1195 of file flutter_windows_engine_unittests.cc.

1195  {
1196  FlutterWindowsEngineBuilder builder{GetContext()};
1197 
1198  auto engine = builder.Build();
1199  auto window_binding_handler =
1200  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1201  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1202 
1203  EngineModifier modifier(engine.get());
1204  modifier.SetImplicitView(&view);
1205  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1206  // Sets lifecycle state to resumed.
1207  engine->Run();
1208 
1209  // Ensure HWND(1) is in the set of visible windows before hiding it.
1210  engine->ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), WM_SHOWWINDOW,
1211  TRUE, NULL);
1212  engine->ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), WM_SHOWWINDOW,
1213  FALSE, NULL);
1214 
1215  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1216  PumpMessage();
1217  }
1218 
1219  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1220  AppLifecycleState::kHidden);
1221 }

References flutter::kHidden.

◆ TEST_F() [39/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
GetExecutableName   
)

Definition at line 702 of file flutter_windows_engine_unittests.cc.

702  {
703  FlutterWindowsEngineBuilder builder{GetContext()};
704  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
705  EXPECT_EQ(engine->GetExecutableName(), "flutter_windows_unittests.exe");
706 }

◆ TEST_F() [40/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
InnerWindowHidden   
)

Definition at line 1223 of file flutter_windows_engine_unittests.cc.

1223  {
1224  FlutterWindowsEngineBuilder builder{GetContext()};
1225  HWND outer = reinterpret_cast<HWND>(1);
1226  HWND inner = reinterpret_cast<HWND>(2);
1227 
1228  auto engine = builder.Build();
1229  auto window_binding_handler =
1230  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1231  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1232  ON_CALL(view, GetWindowHandle).WillByDefault([=]() { return inner; });
1233 
1234  EngineModifier modifier(engine.get());
1235  modifier.SetImplicitView(&view);
1236  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1237  // Sets lifecycle state to resumed.
1238  engine->Run();
1239 
1240  // Show both top-level and Flutter window.
1241  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1242  outer, WM_SHOWWINDOW, TRUE, NULL);
1243  view.OnWindowStateEvent(inner, WindowStateEvent::kShow);
1244  view.OnWindowStateEvent(inner, WindowStateEvent::kFocus);
1245 
1246  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1247  PumpMessage();
1248  }
1249 
1250  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1251  AppLifecycleState::kResumed);
1252 
1253  // Hide Flutter window, but not top level window.
1254  view.OnWindowStateEvent(inner, WindowStateEvent::kHide);
1255 
1256  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1257  PumpMessage();
1258  }
1259 
1260  // The top-level window is still visible, so we ought not enter hidden state.
1261  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1262  AppLifecycleState::kInactive);
1263 }

References flutter::kFocus, flutter::kHide, flutter::kInactive, flutter::kResumed, and flutter::kShow.

◆ TEST_F() [41/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
LifecycleManagerDisabledByDefault   
)

Definition at line 1083 of file flutter_windows_engine_unittests.cc.

1083  {
1084  FlutterWindowsEngineBuilder builder{GetContext()};
1085 
1086  auto engine = builder.Build();
1087  auto window_binding_handler =
1088  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1089  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1090 
1091  EngineModifier modifier(engine.get());
1092  modifier.SetImplicitView(&view);
1093  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1094  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1095  EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(0);
1096  modifier.SetLifecycleManager(std::move(handler));
1097 
1098  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
1099  0);
1100 }

◆ TEST_F() [42/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
LifecycleStateToFrom   
)

Definition at line 1317 of file flutter_windows_engine_unittests.cc.

1317  {
1318  FlutterWindowsEngineBuilder builder{GetContext()};
1319  builder.SetDartEntrypoint("enableLifecycleToFrom");
1320  bool enabled_lifecycle = false;
1321  bool dart_responded = false;
1322 
1323  auto engine = builder.Build();
1324  auto window_binding_handler =
1325  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1326  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1327 
1328  EngineModifier modifier(engine.get());
1329  modifier.SetImplicitView(&view);
1330  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1331  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1332  EXPECT_CALL(*handler, SetLifecycleState)
1333  .WillRepeatedly([handler_ptr = handler.get()](AppLifecycleState state) {
1334  handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1335  });
1336  handler->begin_processing_callback = [&]() { enabled_lifecycle = true; };
1337  modifier.SetLifecycleManager(std::move(handler));
1338 
1339  auto binary_messenger =
1340  std::make_unique<BinaryMessengerImpl>(engine->messenger());
1341  binary_messenger->SetMessageHandler(
1342  "flutter/unittest",
1343  [&](const uint8_t* message, size_t message_size, BinaryReply reply) {
1344  std::string contents(message, message + message_size);
1345  EXPECT_NE(contents.find("AppLifecycleState."), std::string::npos);
1346  dart_responded = true;
1347  char response[] = "";
1348  reply(reinterpret_cast<uint8_t*>(response), 0);
1349  });
1350 
1351  engine->Run();
1352 
1353  while (!enabled_lifecycle) {
1354  engine->task_runner()->ProcessTasks();
1355  }
1356 
1357  HWND hwnd = reinterpret_cast<HWND>(1);
1358  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
1359  view.OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
1360 
1361  while (!dart_responded) {
1362  engine->task_runner()->ProcessTasks();
1363  }
1364 }

References flutter::kHide, flutter::kShow, and message.

◆ TEST_F() [43/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
LifecycleStateTransition   
)

Definition at line 1141 of file flutter_windows_engine_unittests.cc.

1141  {
1142  FlutterWindowsEngineBuilder builder{GetContext()};
1143 
1144  auto engine = builder.Build();
1145  auto window_binding_handler =
1146  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1147  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1148 
1149  EngineModifier modifier(engine.get());
1150  modifier.SetImplicitView(&view);
1151  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1152  engine->Run();
1153 
1154  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1155  (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
1156 
1157  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1158  PumpMessage();
1159  }
1160 
1161  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1162  AppLifecycleState::kInactive);
1163 
1164  engine->lifecycle_manager()->OnWindowStateEvent((HWND)1,
1165  WindowStateEvent::kFocus);
1166 
1167  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1168  PumpMessage();
1169  }
1170 
1171  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1172  AppLifecycleState::kResumed);
1173 
1174  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1175  (HWND)1, WM_SIZE, SIZE_MINIMIZED, 0);
1176 
1177  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1178  PumpMessage();
1179  }
1180 
1181  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1182  AppLifecycleState::kHidden);
1183 
1184  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1185  (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
1186 
1187  while (engine->lifecycle_manager()->IsUpdateStateScheduled()) {
1188  PumpMessage();
1189  }
1190 
1191  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1192  AppLifecycleState::kInactive);
1193 }

References flutter::kFocus, flutter::kHidden, flutter::kInactive, and flutter::kResumed.

◆ TEST_F() [44/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
MergedUIThread   
)

Definition at line 1467 of file flutter_windows_engine_unittests.cc.

1467  {
1468  auto& context = GetContext();
1469  WindowsConfigBuilder builder{context};
1470  builder.SetDartEntrypoint("mergedUIThread");
1471  builder.SetUIThreadPolicy(FlutterDesktopUIThreadPolicy::RunOnPlatformThread);
1472 
1473  std::optional<std::thread::id> ui_thread_id;
1474 
1475  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
1476  ui_thread_id = std::this_thread::get_id();
1477  });
1478  context.AddNativeFunction("Signal", native_entry);
1479 
1480  EnginePtr engine{builder.RunHeadless()};
1481  while (!ui_thread_id) {
1482  PumpMessage();
1483  }
1484  ASSERT_EQ(*ui_thread_id, std::this_thread::get_id());
1485 }
RunOnPlatformThread
@ RunOnPlatformThread
Definition: flutter_windows.h:58

References RunOnPlatformThread.

◆ TEST_F() [45/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
OnViewFocusChangeRequest   
)

Definition at line 1487 of file flutter_windows_engine_unittests.cc.

1487  {
1488  FlutterWindowsEngineBuilder builder{GetContext()};
1489  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1490  auto window_binding_handler =
1491  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1492  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1493 
1494  EngineModifier modifier(engine.get());
1495  modifier.SetImplicitView(&view);
1496 
1497  FlutterViewFocusChangeRequest request;
1498  request.view_id = kImplicitViewId;
1499 
1500  EXPECT_CALL(view, Focus()).WillOnce(Return(true));
1501  modifier.OnViewFocusChangeRequest(&request);
1502 }

References flutter::kImplicitViewId.

◆ TEST_F() [46/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
PlatformMessageRespondOnDifferentThread   
)

Definition at line 484 of file flutter_windows_engine_unittests.cc.

484  {
485  FlutterWindowsEngineBuilder builder{GetContext()};
486  builder.SetDartEntrypoint("hiPlatformChannels");
487 
488  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
489 
490  EngineModifier modifier(engine.get());
491  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
492 
493  auto binary_messenger =
494  std::make_unique<BinaryMessengerImpl>(engine->messenger());
495 
496  engine->Run();
497  bool did_call_callback = false;
498  bool did_call_reply = false;
499  bool did_call_dart_reply = false;
500  std::string channel = "hi";
501  std::unique_ptr<std::thread> reply_thread;
502  binary_messenger->SetMessageHandler(
503  channel,
504  [&did_call_callback, &did_call_dart_reply, &reply_thread](
505  const uint8_t* message, size_t message_size, BinaryReply reply) {
506  if (message_size == 5) {
507  EXPECT_EQ(message[0], static_cast<uint8_t>('h'));
508  reply_thread.reset(new std::thread([reply = std::move(reply)]() {
509  char response[] = {'b', 'y', 'e'};
510  reply(reinterpret_cast<uint8_t*>(response), 3);
511  }));
512  did_call_callback = true;
513  } else {
514  EXPECT_EQ(message_size, 3);
515  EXPECT_EQ(message[0], static_cast<uint8_t>('b'));
516  did_call_dart_reply = true;
517  }
518  });
519  char payload[] = {'h', 'e', 'l', 'l', 'o'};
520  binary_messenger->Send(
521  channel, reinterpret_cast<uint8_t*>(payload), 5,
522  [&did_call_reply](const uint8_t* reply, size_t reply_size) {
523  EXPECT_EQ(reply_size, 5);
524  EXPECT_EQ(reply[0], static_cast<uint8_t>('h'));
525  did_call_reply = true;
526  });
527  // Rely on timeout mechanism in CI.
528  while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
529  engine->task_runner()->ProcessTasks();
530  }
531  ASSERT_TRUE(reply_thread);
532  reply_thread->join();
533 }

References message.

◆ TEST_F() [47/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
PlatformMessageRoundTrip   
)

Definition at line 439 of file flutter_windows_engine_unittests.cc.

439  {
440  FlutterWindowsEngineBuilder builder{GetContext()};
441  builder.SetDartEntrypoint("hiPlatformChannels");
442 
443  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
444  EngineModifier modifier(engine.get());
445  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
446 
447  auto binary_messenger =
448  std::make_unique<BinaryMessengerImpl>(engine->messenger());
449 
450  engine->Run();
451  bool did_call_callback = false;
452  bool did_call_reply = false;
453  bool did_call_dart_reply = false;
454  std::string channel = "hi";
455  binary_messenger->SetMessageHandler(
456  channel,
457  [&did_call_callback, &did_call_dart_reply](
458  const uint8_t* message, size_t message_size, BinaryReply reply) {
459  if (message_size == 5) {
460  EXPECT_EQ(message[0], static_cast<uint8_t>('h'));
461  char response[] = {'b', 'y', 'e'};
462  reply(reinterpret_cast<uint8_t*>(response), 3);
463  did_call_callback = true;
464  } else {
465  EXPECT_EQ(message_size, 3);
466  EXPECT_EQ(message[0], static_cast<uint8_t>('b'));
467  did_call_dart_reply = true;
468  }
469  });
470  char payload[] = {'h', 'e', 'l', 'l', 'o'};
471  binary_messenger->Send(
472  channel, reinterpret_cast<uint8_t*>(payload), 5,
473  [&did_call_reply](const uint8_t* reply, size_t reply_size) {
474  EXPECT_EQ(reply_size, 5);
475  EXPECT_EQ(reply[0], static_cast<uint8_t>('h'));
476  did_call_reply = true;
477  });
478  // Rely on timeout mechanism in CI.
479  while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
480  engine->task_runner()->ProcessTasks();
481  }
482 }

References message.

◆ TEST_F() [48/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
PostRasterThreadTask   
)

Definition at line 751 of file flutter_windows_engine_unittests.cc.

751  {
752  FlutterWindowsEngineBuilder builder{GetContext()};
753  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
754  EngineModifier modifier(engine.get());
755 
756  modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
757  PostRenderThreadTask, ([](auto engine, auto callback, auto context) {
758  callback(context);
759  return kSuccess;
760  }));
761 
762  bool called = false;
763  engine->PostRasterThreadTask([&called]() { called = true; });
764 
765  EXPECT_TRUE(called);
766 }

References callback.

◆ TEST_F() [49/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
ReceivePlatformViewMessage   
)

Definition at line 1391 of file flutter_windows_engine_unittests.cc.

1391  {
1392  FlutterWindowsEngineBuilder builder{GetContext()};
1393  builder.SetDartEntrypoint("sendCreatePlatformViewMethod");
1394  auto engine = builder.Build();
1395 
1396  EngineModifier modifier{engine.get()};
1397  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1398 
1399  bool received_call = false;
1400 
1401  auto manager = std::make_unique<MockPlatformViewManager>(engine.get());
1402  EXPECT_CALL(*manager, AddPlatformView)
1403  .WillOnce([&](PlatformViewId id, std::string_view type_name) {
1404  received_call = true;
1405  return true;
1406  });
1407  modifier.SetPlatformViewPlugin(std::move(manager));
1408 
1409  engine->Run();
1410 
1411  while (!received_call) {
1412  engine->task_runner()->ProcessTasks();
1413  }
1414 }
PlatformViewId
int64_t PlatformViewId
Definition: flutter_windows_internal.h:42

◆ TEST_F() [50/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
RemoveViewFailureDoesNotHang   
)

Definition at line 1449 of file flutter_windows_engine_unittests.cc.

1449  {
1450  FlutterWindowsEngineBuilder builder{GetContext()};
1451  builder.SetDartEntrypoint("sendCreatePlatformViewMethod");
1452  auto engine = builder.Build();
1453 
1454  EngineModifier modifier{engine.get()};
1455 
1456  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1457  modifier.embedder_api().RemoveView = MOCK_ENGINE_PROC(
1458  RemoveView,
1459  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
1460  const FlutterRemoveViewInfo* info) { return kInternalInconsistency; });
1461 
1462  ASSERT_TRUE(engine->Run());
1463  EXPECT_DEBUG_DEATH(engine->RemoveView(123),
1464  "FlutterEngineRemoveView returned an unexpected result");
1465 }

References flutter::FlutterEngine::Run().

◆ TEST_F() [51/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
RunDoesExpectedInitialization   
)

Definition at line 137 of file flutter_windows_engine_unittests.cc.

137  {
138  FlutterWindowsEngineBuilder builder{GetContext()};
139  builder.AddDartEntrypointArgument("arg1");
140  builder.AddDartEntrypointArgument("arg2");
141 
142  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
143 
144  HMONITOR mock_monitor = reinterpret_cast<HMONITOR>(1);
145 
146  MONITORINFOEXW monitor_info = {};
147  monitor_info.cbSize = sizeof(MONITORINFOEXW);
148  monitor_info.rcMonitor = {0, 0, 1920, 1080};
149  monitor_info.rcWork = {0, 0, 1920, 1080};
150  monitor_info.dwFlags = MONITORINFOF_PRIMARY;
151  wcscpy_s(monitor_info.szDevice, L"\\\\.\\DISPLAY1");
152 
153  EXPECT_CALL(*windows_proc_table, GetMonitorInfoW(mock_monitor, _))
154  .WillRepeatedly(DoAll(SetArgPointee<1>(monitor_info), Return(TRUE)));
155 
156  EXPECT_CALL(*windows_proc_table, EnumDisplayMonitors(nullptr, nullptr, _, _))
157  .WillRepeatedly([&](HDC hdc, LPCRECT lprcClip, MONITORENUMPROC lpfnEnum,
158  LPARAM dwData) {
159  lpfnEnum(mock_monitor, nullptr, &monitor_info.rcMonitor, dwData);
160  return TRUE;
161  });
162 
163  EXPECT_CALL(*windows_proc_table, GetDpiForMonitor(mock_monitor, _))
164  .WillRepeatedly(Return(96));
165 
166  // Mock locale information
167  EXPECT_CALL(*windows_proc_table, GetThreadPreferredUILanguages(_, _, _, _))
168  .WillRepeatedly(
169  [](DWORD flags, PULONG count, PZZWSTR languages, PULONG length) {
170  // We need to mock the locale information twice because the first
171  // call is to get the size and the second call is to fill the
172  // buffer.
173  if (languages == nullptr) {
174  // First call is to get the size
175  *count = 1; // One language
176  *length = 10; // "fr-FR\0\0" (double null-terminated)
177  return TRUE;
178  } else {
179  // Second call is to fill the buffer
180  *count = 1;
181  // Fill with "fr-FR\0\0" (double null-terminated)
182  wchar_t* lang_buffer = languages;
183  wcscpy(lang_buffer, L"fr-FR");
184  // Move past the first null terminator to add the second
185  lang_buffer += wcslen(L"fr-FR") + 1;
186  *lang_buffer = L'\0';
187  return TRUE;
188  }
189  });
190 
191  builder.SetWindowsProcTable(windows_proc_table);
192 
193  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
194  EngineModifier modifier(engine.get());
195 
196  // The engine should be run with expected configuration values.
197  bool run_called = false;
198  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
199  Run, ([&run_called, engine_instance = engine.get()](
200  size_t version, const FlutterRendererConfig* config,
201  const FlutterProjectArgs* args, void* user_data,
202  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
203  run_called = true;
204  *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
205 
206  EXPECT_EQ(version, FLUTTER_ENGINE_VERSION);
207  EXPECT_NE(config, nullptr);
208  // We have an EGL manager, so this should be using OpenGL.
209  EXPECT_EQ(config->type, kOpenGL);
210  EXPECT_EQ(user_data, engine_instance);
211  // Spot-check arguments.
212  EXPECT_NE(args->assets_path, nullptr);
213  EXPECT_NE(args->icu_data_path, nullptr);
214  EXPECT_EQ(args->dart_entrypoint_argc, 2U);
215  EXPECT_EQ(strcmp(args->dart_entrypoint_argv[0], "arg1"), 0);
216  EXPECT_EQ(strcmp(args->dart_entrypoint_argv[1], "arg2"), 0);
217  EXPECT_NE(args->platform_message_callback, nullptr);
218  EXPECT_NE(args->custom_task_runners, nullptr);
219  EXPECT_NE(args->custom_task_runners->thread_priority_setter, nullptr);
220  EXPECT_EQ(args->custom_dart_entrypoint, nullptr);
221  EXPECT_NE(args->vsync_callback, nullptr);
222  EXPECT_EQ(args->update_semantics_callback, nullptr);
223  EXPECT_NE(args->update_semantics_callback2, nullptr);
224  EXPECT_EQ(args->update_semantics_node_callback, nullptr);
225  EXPECT_EQ(args->update_semantics_custom_action_callback, nullptr);
226  EXPECT_NE(args->view_focus_change_request_callback, nullptr);
227 
228  args->custom_task_runners->thread_priority_setter(
229  FlutterThreadPriority::kRaster);
230  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
231  THREAD_PRIORITY_ABOVE_NORMAL);
232  return kSuccess;
233  }));
234  // Accessibility updates must do nothing when the embedder engine is mocked
235  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
236  UpdateAccessibilityFeatures,
237  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
238  FlutterAccessibilityFeature flags) { return kSuccess; });
239 
240  // It should send locale info.
241  bool update_locales_called = false;
242  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
243  UpdateLocales,
244  ([&update_locales_called](auto engine, const FlutterLocale** locales,
245  size_t locales_count) {
246  update_locales_called = true;
247 
248  EXPECT_GT(locales_count, 0);
249  EXPECT_NE(locales, nullptr);
250 
251  return kSuccess;
252  }));
253 
254  // And it should send initial settings info.
255  bool settings_message_sent = false;
256  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
257  SendPlatformMessage,
258  ([&settings_message_sent](auto engine, auto message) {
259  if (std::string(message->channel) == std::string("flutter/settings")) {
260  settings_message_sent = true;
261  }
262 
263  return kSuccess;
264  }));
265 
266  // And it should send display info.
267  bool notify_display_update_called = false;
268 
269  modifier.embedder_api().NotifyDisplayUpdate = MOCK_ENGINE_PROC(
270  NotifyDisplayUpdate,
271  ([&notify_display_update_called](
272  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
273  const FlutterEngineDisplaysUpdateType update_type,
274  const FlutterEngineDisplay* embedder_displays,
275  size_t display_count) {
276  EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
277  notify_display_update_called = true;
278  return kSuccess;
279  }));
280 
281  // Set the EGL manager to !nullptr to test ANGLE rendering.
282  modifier.SetEGLManager(std::make_unique<egl::MockManager>());
283 
284  engine->Run();
285 
286  EXPECT_TRUE(run_called);
287  EXPECT_TRUE(update_locales_called);
288  EXPECT_TRUE(settings_message_sent);
289  EXPECT_TRUE(notify_display_update_called);
290 
291  // Ensure that deallocation doesn't call the actual Shutdown with the bogus
292  // engine pointer that the overridden Run returned.
293  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
294  modifier.ReleaseEGLManager();
295 }

References flutter::GetDpiForMonitor(), message, and user_data.

◆ TEST_F() [52/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
RunHeadless   
)

Definition at line 55 of file flutter_windows_engine_unittests.cc.

55  {
56  FlutterWindowsEngineBuilder builder{GetContext()};
57  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
58 
59  EngineModifier modifier(engine.get());
60  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
61 
62  ASSERT_TRUE(engine->Run());
63  ASSERT_EQ(engine->view(kImplicitViewId), nullptr);
64  ASSERT_EQ(engine->view(123), nullptr);
65 }

References flutter::kImplicitViewId.

◆ TEST_F() [53/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
RunWithoutANGLEOnImpellerFailsToStart   
)

Definition at line 377 of file flutter_windows_engine_unittests.cc.

377  {
378  FlutterWindowsEngineBuilder builder{GetContext()};
379  builder.SetSwitches({"--enable-impeller=true"});
380  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
381  EngineModifier modifier(engine.get());
382 
383  modifier.embedder_api().NotifyDisplayUpdate =
384  MOCK_ENGINE_PROC(NotifyDisplayUpdate,
385  ([engine_instance = engine.get()](
386  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
387  const FlutterEngineDisplaysUpdateType update_type,
388  const FlutterEngineDisplay* embedder_displays,
389  size_t display_count) { return kSuccess; }));
390 
391  // Accessibility updates must do nothing when the embedder engine is mocked
392  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
393  UpdateAccessibilityFeatures,
394  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
395  FlutterAccessibilityFeature flags) { return kSuccess; });
396 
397  // Stub out UpdateLocales and SendPlatformMessage as we don't have a fully
398  // initialized engine instance.
399  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
400  UpdateLocales, ([](auto engine, const FlutterLocale** locales,
401  size_t locales_count) { return kSuccess; }));
402  modifier.embedder_api().SendPlatformMessage =
403  MOCK_ENGINE_PROC(SendPlatformMessage,
404  ([](auto engine, auto message) { return kSuccess; }));
405 
406  // Set the EGL manager to nullptr to test software fallback path.
407  modifier.SetEGLManager(nullptr);
408 
409  EXPECT_FALSE(engine->Run());
410 }

References message.

◆ TEST_F() [54/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
RunWithoutANGLEUsesSoftware   
)

Definition at line 324 of file flutter_windows_engine_unittests.cc.

324  {
325  FlutterWindowsEngineBuilder builder{GetContext()};
326  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
327  EngineModifier modifier(engine.get());
328 
329  modifier.embedder_api().NotifyDisplayUpdate =
330  MOCK_ENGINE_PROC(NotifyDisplayUpdate,
331  ([engine_instance = engine.get()](
332  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
333  const FlutterEngineDisplaysUpdateType update_type,
334  const FlutterEngineDisplay* embedder_displays,
335  size_t display_count) { return kSuccess; }));
336 
337  // The engine should be run with expected configuration values.
338  bool run_called = false;
339  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
340  Run, ([&run_called, engine_instance = engine.get()](
341  size_t version, const FlutterRendererConfig* config,
342  const FlutterProjectArgs* args, void* user_data,
343  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
344  run_called = true;
345  *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
346  // We don't have an EGL Manager, so we should be using software.
347  EXPECT_EQ(config->type, kSoftware);
348  return kSuccess;
349  }));
350  // Accessibility updates must do nothing when the embedder engine is mocked
351  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
352  UpdateAccessibilityFeatures,
353  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
354  FlutterAccessibilityFeature flags) { return kSuccess; });
355 
356  // Stub out UpdateLocales and SendPlatformMessage as we don't have a fully
357  // initialized engine instance.
358  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
359  UpdateLocales, ([](auto engine, const FlutterLocale** locales,
360  size_t locales_count) { return kSuccess; }));
361  modifier.embedder_api().SendPlatformMessage =
362  MOCK_ENGINE_PROC(SendPlatformMessage,
363  ([](auto engine, auto message) { return kSuccess; }));
364 
365  // Set the EGL manager to nullptr to test software fallback path.
366  modifier.SetEGLManager(nullptr);
367 
368  engine->Run();
369 
370  EXPECT_TRUE(run_called);
371 
372  // Ensure that deallocation doesn't call the actual Shutdown with the bogus
373  // engine pointer that the overridden Run returned.
374  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
375 }

References message, and user_data.

◆ TEST_F() [55/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
ScheduleFrame   
)

Definition at line 670 of file flutter_windows_engine_unittests.cc.

670  {
671  FlutterWindowsEngineBuilder builder{GetContext()};
672  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
673  EngineModifier modifier(engine.get());
674 
675  bool called = false;
676  modifier.embedder_api().ScheduleFrame =
677  MOCK_ENGINE_PROC(ScheduleFrame, ([&called](auto engine) {
678  called = true;
679  return kSuccess;
680  }));
681 
682  engine->ScheduleFrame();
683  EXPECT_TRUE(called);
684 }

◆ TEST_F() [56/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
SendPlatformMessageWithoutResponse   
)

Definition at line 412 of file flutter_windows_engine_unittests.cc.

412  {
413  FlutterWindowsEngineBuilder builder{GetContext()};
414  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
415  EngineModifier modifier(engine.get());
416 
417  const char* channel = "test";
418  const std::vector<uint8_t> test_message = {1, 2, 3, 4};
419 
420  // Without a response, SendPlatformMessage should be a simple pass-through.
421  bool called = false;
422  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
423  SendPlatformMessage, ([&called, test_message](auto engine, auto message) {
424  called = true;
425  EXPECT_STREQ(message->channel, "test");
426  EXPECT_EQ(message->message_size, test_message.size());
427  EXPECT_EQ(memcmp(message->message, test_message.data(),
428  message->message_size),
429  0);
430  EXPECT_EQ(message->response_handle, nullptr);
431  return kSuccess;
432  }));
433 
434  engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
435  nullptr, nullptr);
436  EXPECT_TRUE(called);
437 }

References message.

◆ TEST_F() [57/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
SendPlatformMessageWithResponse   
)

Definition at line 535 of file flutter_windows_engine_unittests.cc.

535  {
536  FlutterWindowsEngineBuilder builder{GetContext()};
537  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
538  EngineModifier modifier(engine.get());
539 
540  const char* channel = "test";
541  const std::vector<uint8_t> test_message = {1, 2, 3, 4};
542  auto* dummy_response_handle =
543  reinterpret_cast<FlutterPlatformMessageResponseHandle*>(5);
544  const FlutterDesktopBinaryReply reply_handler = [](auto... args) {};
545  void* reply_user_data = reinterpret_cast<void*>(6);
546 
547  // When a response is requested, a handle should be created, passed as part
548  // of the message, and then released.
549  bool create_response_handle_called = false;
550  modifier.embedder_api().PlatformMessageCreateResponseHandle =
551  MOCK_ENGINE_PROC(
552  PlatformMessageCreateResponseHandle,
553  ([&create_response_handle_called, &reply_handler, reply_user_data,
554  dummy_response_handle](auto engine, auto reply, auto user_data,
555  auto response_handle) {
556  create_response_handle_called = true;
557  EXPECT_EQ(reply, reply_handler);
558  EXPECT_EQ(user_data, reply_user_data);
559  EXPECT_NE(response_handle, nullptr);
560  *response_handle = dummy_response_handle;
561  return kSuccess;
562  }));
563  bool release_response_handle_called = false;
564  modifier.embedder_api().PlatformMessageReleaseResponseHandle =
565  MOCK_ENGINE_PROC(
566  PlatformMessageReleaseResponseHandle,
567  ([&release_response_handle_called, dummy_response_handle](
568  auto engine, auto response_handle) {
569  release_response_handle_called = true;
570  EXPECT_EQ(response_handle, dummy_response_handle);
571  return kSuccess;
572  }));
573  bool send_message_called = false;
574  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
575  SendPlatformMessage, ([&send_message_called, test_message,
576  dummy_response_handle](auto engine, auto message) {
577  send_message_called = true;
578  EXPECT_STREQ(message->channel, "test");
579  EXPECT_EQ(message->message_size, test_message.size());
580  EXPECT_EQ(memcmp(message->message, test_message.data(),
581  message->message_size),
582  0);
583  EXPECT_EQ(message->response_handle, dummy_response_handle);
584  return kSuccess;
585  }));
586 
587  engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
588  reply_handler, reply_user_data);
589  EXPECT_TRUE(create_response_handle_called);
590  EXPECT_TRUE(release_response_handle_called);
591  EXPECT_TRUE(send_message_called);
592 }
FlutterDesktopBinaryReply
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
Definition: flutter_messenger.h:26

References message, and user_data.

◆ TEST_F() [58/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
SetNextFrameCallback   
)

Definition at line 686 of file flutter_windows_engine_unittests.cc.

686  {
687  FlutterWindowsEngineBuilder builder{GetContext()};
688  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
689  EngineModifier modifier(engine.get());
690 
691  bool called = false;
692  modifier.embedder_api().SetNextFrameCallback = MOCK_ENGINE_PROC(
693  SetNextFrameCallback, ([&called](auto engine, auto callback, auto data) {
694  called = true;
695  return kSuccess;
696  }));
697 
698  engine->SetNextFrameCallback([]() {});
699  EXPECT_TRUE(called);
700 }

References callback.

◆ TEST_F() [59/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
SetsThreadPriority   
)

Definition at line 618 of file flutter_windows_engine_unittests.cc.

618  {
619  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kBackground);
620  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
621  THREAD_PRIORITY_BELOW_NORMAL);
622 
623  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kDisplay);
624  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
625  THREAD_PRIORITY_ABOVE_NORMAL);
626 
627  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kRaster);
628  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
629  THREAD_PRIORITY_ABOVE_NORMAL);
630 
631  // FlutterThreadPriority::kNormal does not change thread priority, reset to 0
632  // here.
633  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
634 
635  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kNormal);
636  EXPECT_EQ(GetThreadPriority(GetCurrentThread()), THREAD_PRIORITY_NORMAL);
637 }
flutter::WindowsPlatformThreadPrioritySetter
static void WindowsPlatformThreadPrioritySetter(FlutterThreadPriority priority)
Definition: flutter_windows_engine.h:62

References flutter::WindowsPlatformThreadPrioritySetter().

◆ TEST_F() [60/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
TaskRunnerDelayedTask   
)

Definition at line 67 of file flutter_windows_engine_unittests.cc.

67  {
68  bool finished = false;
69  auto runner = std::make_unique<TaskRunner>(
70  [] {
71  return static_cast<uint64_t>(
72  fml::TimePoint::Now().ToEpochDelta().ToNanoseconds());
73  },
74  [&](const FlutterTask*) { finished = true; });
75  runner->PostFlutterTask(
76  FlutterTask{},
77  static_cast<uint64_t>((fml::TimePoint::Now().ToEpochDelta() +
78  fml::TimeDelta::FromMilliseconds(50))
79  .ToNanoseconds()));
80  auto start = fml::TimePoint::Now();
81  while (!finished) {
82  PumpMessage();
83  }
84  auto duration = fml::TimePoint::Now() - start;
85  EXPECT_GE(duration, fml::TimeDelta::FromMilliseconds(50));
86 }

◆ TEST_F() [61/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
TaskRunnerDoesNotDeadlock   
)

Definition at line 89 of file flutter_windows_engine_unittests.cc.

89  {
90  auto runner = std::make_unique<TaskRunner>(
91  [] {
92  return static_cast<uint64_t>(
93  fml::TimePoint::Now().ToEpochDelta().ToNanoseconds());
94  },
95  [&](const FlutterTask*) {});
96 
97  struct RunnerHolder {
98  void PostTaskLoop() {
99  runner->PostTask([this] { PostTaskLoop(); });
100  }
101  std::unique_ptr<TaskRunner> runner;
102  };
103 
104  RunnerHolder container{.runner = std::move(runner)};
105  // Spam flutter tasks.
106  container.PostTaskLoop();
107 
108  const LPCWSTR class_name = L"FlutterTestWindowClass";
109  WNDCLASS wc = {0};
110  wc.lpfnWndProc = DefWindowProc;
111  wc.lpszClassName = class_name;
112  RegisterClass(&wc);
113 
114  HWND window;
115  container.runner->PostTask([&] {
116  window = CreateWindowEx(0, class_name, L"Empty Window", WS_OVERLAPPEDWINDOW,
117  CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, nullptr,
118  nullptr, nullptr, nullptr);
119  ShowWindow(window, SW_SHOW);
120  });
121 
122  while (true) {
123  ::MSG msg;
124  if (::GetMessage(&msg, nullptr, 0, 0)) {
125  if (msg.message == WM_PAINT) {
126  break;
127  }
128  ::TranslateMessage(&msg);
129  ::DispatchMessage(&msg);
130  }
131  }
132 
133  DestroyWindow(window);
134  UnregisterClassW(class_name, nullptr);
135 }

◆ TEST_F() [62/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
TestExit   
)

Definition at line 908 of file flutter_windows_engine_unittests.cc.

908  {
909  FlutterWindowsEngineBuilder builder{GetContext()};
910  builder.SetDartEntrypoint("exitTestExit");
911  bool finished = false;
912 
913  auto engine = builder.Build();
914  auto window_binding_handler =
915  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
916  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
917 
918  EngineModifier modifier(engine.get());
919  modifier.SetImplicitView(&view);
920  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
921  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
922  EXPECT_CALL(*handler, Quit)
923  .WillOnce([&finished](std::optional<HWND> hwnd,
924  std::optional<WPARAM> wparam,
925  std::optional<LPARAM> lparam,
926  UINT exit_code) { finished = exit_code == 0; });
927  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(true));
928  modifier.SetLifecycleManager(std::move(handler));
929 
930  engine->lifecycle_manager()->BeginProcessingExit();
931 
932  engine->Run();
933 
934  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
935  0);
936 
937  // The test will only succeed when this while loop exits. Otherwise it will
938  // timeout.
939  while (!finished) {
940  engine->task_runner()->ProcessTasks();
941  }
942 }

◆ TEST_F() [63/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
TestExitCancel   
)

Definition at line 944 of file flutter_windows_engine_unittests.cc.

944  {
945  FlutterWindowsEngineBuilder builder{GetContext()};
946  builder.SetDartEntrypoint("exitTestCancel");
947  bool did_call = false;
948 
949  auto engine = builder.Build();
950  auto window_binding_handler =
951  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
952  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
953 
954  EngineModifier modifier(engine.get());
955  modifier.SetImplicitView(&view);
956  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
957  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
958  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(true));
959  EXPECT_CALL(*handler, Quit).Times(0);
960  modifier.SetLifecycleManager(std::move(handler));
961  engine->lifecycle_manager()->BeginProcessingExit();
962 
963  auto binary_messenger =
964  std::make_unique<BinaryMessengerImpl>(engine->messenger());
965  binary_messenger->SetMessageHandler(
966  "flutter/platform", [&did_call](const uint8_t* message,
967  size_t message_size, BinaryReply reply) {
968  std::string contents(message, message + message_size);
969  EXPECT_NE(contents.find("\"method\":\"System.exitApplication\""),
970  std::string::npos);
971  EXPECT_NE(contents.find("\"type\":\"required\""), std::string::npos);
972  EXPECT_NE(contents.find("\"exitCode\":0"), std::string::npos);
973  did_call = true;
974  char response[] = "";
975  reply(reinterpret_cast<uint8_t*>(response), 0);
976  });
977 
978  engine->Run();
979 
980  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
981  0);
982 
983  while (!did_call) {
984  engine->task_runner()->ProcessTasks();
985  }
986 }

References message.

◆ TEST_F() [64/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
TestExitCloseMultiWindow   
)

Definition at line 1050 of file flutter_windows_engine_unittests.cc.

1050  {
1051  FlutterWindowsEngineBuilder builder{GetContext()};
1052  builder.SetDartEntrypoint("exitTestExit");
1053  bool finished = false;
1054 
1055  auto engine = builder.Build();
1056  auto window_binding_handler =
1057  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1058  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1059 
1060  EngineModifier modifier(engine.get());
1061  modifier.SetImplicitView(&view);
1062  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1063  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1064  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce([&finished]() {
1065  finished = true;
1066  return false;
1067  });
1068  // Quit should not be called when there is more than one window.
1069  EXPECT_CALL(*handler, Quit).Times(0);
1070  modifier.SetLifecycleManager(std::move(handler));
1071  engine->lifecycle_manager()->BeginProcessingExit();
1072 
1073  engine->Run();
1074 
1075  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
1076  0);
1077 
1078  while (!finished) {
1079  engine->task_runner()->ProcessTasks();
1080  }
1081 }

◆ TEST_F() [65/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
TestExitSecondCloseMessage   
)

Definition at line 991 of file flutter_windows_engine_unittests.cc.

991  {
992  FlutterWindowsEngineBuilder builder{GetContext()};
993  builder.SetDartEntrypoint("exitTestExit");
994  bool second_close = false;
995 
996  auto engine = builder.Build();
997  auto window_binding_handler =
998  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
999  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1000 
1001  EngineModifier modifier(engine.get());
1002  modifier.SetImplicitView(&view);
1003  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1004  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1005  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(true));
1006  EXPECT_CALL(*handler, Quit)
1007  .WillOnce([handler_ptr = handler.get()](
1008  std::optional<HWND> hwnd, std::optional<WPARAM> wparam,
1009  std::optional<LPARAM> lparam, UINT exit_code) {
1010  handler_ptr->WindowsLifecycleManager::Quit(hwnd, wparam, lparam,
1011  exit_code);
1012  });
1013  EXPECT_CALL(*handler, DispatchMessage)
1014  .WillRepeatedly(
1015  [&engine](HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
1016  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1017  hwnd, msg, wparam, lparam);
1018  });
1019  modifier.SetLifecycleManager(std::move(handler));
1020  engine->lifecycle_manager()->BeginProcessingExit();
1021 
1022  engine->Run();
1023 
1024  // This delegate will be registered after the lifecycle manager, so it will be
1025  // called only when a message is not consumed by the lifecycle manager. This
1026  // should be called on the second, synthesized WM_CLOSE message that the
1027  // lifecycle manager posts.
1028  engine->window_proc_delegate_manager()->RegisterTopLevelWindowProcDelegate(
1029  [](HWND hwnd, UINT message, WPARAM wpar, LPARAM lpar, void* user_data,
1030  LRESULT* result) {
1031  switch (message) {
1032  case WM_CLOSE: {
1033  bool* called = reinterpret_cast<bool*>(user_data);
1034  *called = true;
1035  return true;
1036  }
1037  }
1038  return false;
1039  },
1040  reinterpret_cast<void*>(&second_close));
1041 
1042  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
1043  0);
1044 
1045  while (!second_close) {
1046  engine->task_runner()->ProcessTasks();
1047  }
1048 }

References message, and user_data.

◆ TEST_F() [66/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
UpdateHighContrastFeature   
)

Definition at line 710 of file flutter_windows_engine_unittests.cc.

710  {
711  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
712  EXPECT_CALL(*windows_proc_table, GetHighContrastEnabled)
713  .WillOnce(Return(true))
714  .WillOnce(Return(false));
715 
716  FlutterWindowsEngineBuilder builder{GetContext()};
717  builder.SetWindowsProcTable(windows_proc_table);
718  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
719  EngineModifier modifier(engine.get());
720 
721  std::optional<FlutterAccessibilityFeature> engine_flags;
722  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
723  UpdateAccessibilityFeatures, ([&engine_flags](auto engine, auto flags) {
724  engine_flags = flags;
725  return kSuccess;
726  }));
727  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
728  SendPlatformMessage,
729  [](auto engine, const auto message) { return kSuccess; });
730 
731  // 1: High contrast is enabled.
732  engine->UpdateHighContrastMode();
733 
734  EXPECT_TRUE(engine->high_contrast_enabled());
735  EXPECT_TRUE(engine_flags.has_value());
736  EXPECT_TRUE(
737  engine_flags.value() &
738  FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
739 
740  // 2: High contrast is disabled.
741  engine_flags.reset();
742  engine->UpdateHighContrastMode();
743 
744  EXPECT_FALSE(engine->high_contrast_enabled());
745  EXPECT_TRUE(engine_flags.has_value());
746  EXPECT_FALSE(
747  engine_flags.value() &
748  FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
749 }

References message.

◆ TEST_F() [67/192]

flutter::testing::TEST_F ( FlutterWindowsEngineTest  ,
UpdateSemanticsMultiView   
)

Definition at line 1504 of file flutter_windows_engine_unittests.cc.

1504  {
1505  auto& context = GetContext();
1506  WindowsConfigBuilder builder{context};
1507  builder.SetDartEntrypoint("sendSemanticsTreeInfo");
1508 
1509  // Setup: a signal for when we have send out all of our semantics updates
1510  bool done = false;
1511  auto native_entry =
1512  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
1513  context.AddNativeFunction("Signal", native_entry);
1514 
1515  // Setup: Create the engine and two views + enable semantics
1516  EnginePtr engine{builder.RunHeadless()};
1517  ASSERT_NE(engine, nullptr);
1518 
1519  auto window_binding_handler1 =
1520  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1521  auto window_binding_handler2 =
1522  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1523 
1524  // The following mocks are required by
1525  // FlutterWindowsView::CreateWindowMetricsEvent so that we create a valid
1526  // view.
1527  EXPECT_CALL(*window_binding_handler1, GetPhysicalWindowBounds)
1528  .WillRepeatedly(testing::Return(PhysicalWindowBounds{100, 100}));
1529  EXPECT_CALL(*window_binding_handler1, GetDpiScale)
1530  .WillRepeatedly(testing::Return(96.0));
1531  EXPECT_CALL(*window_binding_handler2, GetPhysicalWindowBounds)
1532  .WillRepeatedly(testing::Return(PhysicalWindowBounds{200, 200}));
1533  EXPECT_CALL(*window_binding_handler2, GetDpiScale)
1534  .WillRepeatedly(testing::Return(96.0));
1535 
1536  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
1537  EngineModifier modifier{windows_engine};
1538  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1539 
1540  // We want to avoid adding an implicit view as the first view
1541  modifier.SetNextViewId(kImplicitViewId + 1);
1542 
1543  auto view1 = windows_engine->CreateView(std::move(window_binding_handler1),
1544  /*is_sized_to_content=*/false,
1545  BoxConstraints());
1546  auto view2 = windows_engine->CreateView(std::move(window_binding_handler2),
1547  /*is_sized_to_content=*/false,
1548  BoxConstraints());
1549 
1550  // Act: UpdateSemanticsEnabled will trigger the semantics updates
1551  // to get sent.
1552  windows_engine->UpdateSemanticsEnabled(true);
1553 
1554  while (!done) {
1555  windows_engine->task_runner()->ProcessTasks();
1556  }
1557 
1558  auto accessibility_bridge1 = view1->accessibility_bridge().lock();
1559  auto accessibility_bridge2 = view2->accessibility_bridge().lock();
1560 
1561  // Expect: that the semantics trees are updated with their
1562  // respective nodes.
1563  while (
1564  !accessibility_bridge1->GetPlatformNodeFromTree(view1->view_id() + 1)) {
1565  windows_engine->task_runner()->ProcessTasks();
1566  }
1567 
1568  while (
1569  !accessibility_bridge2->GetPlatformNodeFromTree(view2->view_id() + 1)) {
1570  windows_engine->task_runner()->ProcessTasks();
1571  }
1572 
1573  // Rely on timeout mechanism in CI.
1574  auto tree1 = accessibility_bridge1->GetTree();
1575  auto tree2 = accessibility_bridge2->GetTree();
1576  EXPECT_NE(tree1->GetFromId(view1->view_id() + 1), nullptr);
1577  EXPECT_NE(tree2->GetFromId(view2->view_id() + 1), nullptr);
1578 }

References flutter::FlutterWindowsEngine::CreateView(), and flutter::kImplicitViewId.

◆ TEST_F() [68/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
AccessibilityNodeWithoutView   
)

Definition at line 319 of file flutter_window_unittests.cc.

319  {
320  MockFlutterWindow win32window;
321 
322  EXPECT_EQ(win32window.GetNativeViewAccessible(), nullptr);
323 }

◆ TEST_F() [69/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
AlertNode   
)

Definition at line 327 of file flutter_window_unittests.cc.

327  {
328  std::unique_ptr<FlutterWindowsEngine> engine =
329  FlutterWindowsEngineBuilder{GetContext()}.Build();
330  auto win32window = std::make_unique<MockFlutterWindow>();
331  EXPECT_CALL(*win32window.get(), GetAxFragmentRootDelegate())
332  .WillRepeatedly(Return(nullptr));
333  EXPECT_CALL(*win32window.get(), OnWindowStateEvent).Times(AnyNumber());
334  EXPECT_CALL(*win32window.get(), GetWindowHandle).Times(AnyNumber());
335  MockFlutterWindowsView view{engine.get(), std::move(win32window)};
336  std::wstring message = L"Test alert";
337  EXPECT_CALL(view, NotifyWinEventWrapper(_, ax::mojom::Event::kAlert))
338  .Times(1);
339  view.AnnounceAlert(message);
340 
341  IAccessible* alert = view.AlertNode();
342  VARIANT self{.vt = VT_I4, .lVal = CHILDID_SELF};
343  BSTR strptr;
344  alert->get_accName(self, &strptr);
345  EXPECT_EQ(message, strptr);
346 
347  alert->get_accDescription(self, &strptr);
348  EXPECT_EQ(message, strptr);
349 
350  alert->get_accValue(self, &strptr);
351  EXPECT_EQ(message, strptr);
352 
353  VARIANT role;
354  alert->get_accRole(self, &role);
355  EXPECT_EQ(role.vt, VT_I4);
356  EXPECT_EQ(role.lVal, ROLE_SYSTEM_ALERT);
357 }

References message.

◆ TEST_F() [70/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
CachedLifecycleMessage   
)

Definition at line 397 of file flutter_window_unittests.cc.

397  {
398  MockFlutterWindow win32window;
399  EXPECT_CALL(win32window, GetWindowHandle)
400  .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
401  EXPECT_CALL(win32window, OnWindowStateEvent)
402  .WillRepeatedly([&](WindowStateEvent event) {
403  win32window.FlutterWindow::OnWindowStateEvent(event);
404  });
405  EXPECT_CALL(win32window, OnResize).Times(1);
406 
407  // Restore
408  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
409 
410  // Focus
411  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
412 
413  MockWindowBindingHandlerDelegate delegate;
414  bool focused = false;
415  bool restored = false;
416  EXPECT_CALL(delegate, OnWindowStateEvent)
417  .WillRepeatedly([&](HWND hwnd, WindowStateEvent event) {
418  if (event == WindowStateEvent::kFocus) {
419  focused = true;
420  } else if (event == WindowStateEvent::kShow) {
421  restored = true;
422  }
423  });
424 
425  EXPECT_CALL(delegate, OnFocus(Eq(FlutterViewFocusState::kFocused),
426  Eq(FlutterViewFocusDirection::kUndefined)))
427  .Times(1);
428  win32window.SetView(&delegate);
429  EXPECT_TRUE(focused);
430  EXPECT_TRUE(restored);
431 }
flutter::WindowStateEvent
WindowStateEvent
An event representing a change in window state that may update the.
Definition: windows_lifecycle_manager.h:24

References flutter::kFocus, and flutter::kShow.

◆ TEST_F() [71/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
CreateDestroy   
)

Definition at line 121 of file flutter_window_unittests.cc.

121  {
122  std::unique_ptr<FlutterWindowsEngine> engine =
123  FlutterWindowsEngineBuilder{GetContext()}.Build();
124  FlutterWindow window(800, 600, engine->display_manager());
125  ASSERT_TRUE(TRUE);
126 }

◆ TEST_F() [72/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
LifecycleFocusMessages   
)

Definition at line 359 of file flutter_window_unittests.cc.

359  {
360  MockFlutterWindow win32window;
361  EXPECT_CALL(win32window, GetWindowHandle)
362  .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
363  MockWindowBindingHandlerDelegate delegate;
364 
365  WindowStateEvent last_event;
366  EXPECT_CALL(delegate, OnWindowStateEvent)
367  .WillRepeatedly([&last_event](HWND hwnd, WindowStateEvent event) {
368  last_event = event;
369  });
370  EXPECT_CALL(win32window, OnWindowStateEvent)
371  .WillRepeatedly([&](WindowStateEvent event) {
372  win32window.FlutterWindow::OnWindowStateEvent(event);
373  });
374  EXPECT_CALL(win32window, OnResize).Times(AnyNumber());
375 
376  win32window.SetView(&delegate);
377 
378  win32window.InjectWindowMessage(WM_SIZE, 0, 0);
379  EXPECT_EQ(last_event, WindowStateEvent::kHide);
380 
381  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
382  EXPECT_EQ(last_event, WindowStateEvent::kShow);
383 
384  EXPECT_CALL(delegate, OnFocus(Eq(FlutterViewFocusState::kFocused),
385  Eq(FlutterViewFocusDirection::kUndefined)))
386  .Times(1);
387  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
388  EXPECT_EQ(last_event, WindowStateEvent::kFocus);
389 
390  EXPECT_CALL(delegate, OnFocus(Eq(FlutterViewFocusState::kUnfocused),
391  Eq(FlutterViewFocusDirection::kUndefined)))
392  .Times(1);
393  win32window.InjectWindowMessage(WM_KILLFOCUS, 0, 0);
394  EXPECT_EQ(last_event, WindowStateEvent::kUnfocus);
395 }

References flutter::kFocus, flutter::kHide, flutter::kShow, and flutter::kUnfocus.

◆ TEST_F() [73/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnBitmapSurfaceUpdated   
)

Definition at line 128 of file flutter_window_unittests.cc.

128  {
129  std::unique_ptr<FlutterWindowsEngine> engine =
130  FlutterWindowsEngineBuilder{GetContext()}.Build();
131  FlutterWindow win32window(100, 100, engine->display_manager());
132  int old_handle_count = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
133 
134  constexpr size_t row_bytes = 100 * 4;
135  constexpr size_t height = 100;
136  std::array<char, row_bytes * height> allocation;
137  win32window.OnBitmapSurfaceUpdated(allocation.data(), row_bytes, height);
138 
139  int new_handle_count = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
140  // Check GDI resources leak
141  EXPECT_EQ(old_handle_count, new_handle_count);
142 }

References flutter::FlutterWindow::OnBitmapSurfaceUpdated().

◆ TEST_F() [74/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnCursorRectUpdatedHighDPI   
)

Definition at line 160 of file flutter_window_unittests.cc.

160  {
161  MockFlutterWindow win32window;
162  EXPECT_CALL(win32window, GetDpiScale()).WillOnce(Return(1.5));
163 
164  Rect expected_cursor_rect(Point(15, 30), Size(45, 60));
165  EXPECT_CALL(win32window, UpdateCursorRect(expected_cursor_rect)).Times(1);
166 
167  Rect cursor_rect(Point(10, 20), Size(30, 40));
168  win32window.OnCursorRectUpdated(cursor_rect);
169 }

◆ TEST_F() [75/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnCursorRectUpdatedRegularDPI   
)

Definition at line 147 of file flutter_window_unittests.cc.

147  {
148  MockFlutterWindow win32window;
149  EXPECT_CALL(win32window, GetDpiScale()).WillOnce(Return(1.0));
150 
151  Rect cursor_rect(Point(10, 20), Size(30, 40));
152  EXPECT_CALL(win32window, UpdateCursorRect(cursor_rect)).Times(1);
153 
154  win32window.OnCursorRectUpdated(cursor_rect);
155 }

◆ TEST_F() [76/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnPointerStarSendsDeviceType   
)

Definition at line 171 of file flutter_window_unittests.cc.

171  {
172  std::unique_ptr<FlutterWindowsEngine> engine =
173  FlutterWindowsEngineBuilder{GetContext()}.Build();
174  FlutterWindow win32window(100, 100, engine->display_manager());
175  MockWindowBindingHandlerDelegate delegate;
176  EXPECT_CALL(delegate, OnWindowStateEvent).Times(AnyNumber());
177  win32window.SetView(&delegate);
178 
179  // Move
180  EXPECT_CALL(delegate,
181  OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindMouse,
182  kDefaultPointerDeviceId, 0))
183  .Times(1);
184  EXPECT_CALL(delegate,
185  OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindTouch,
186  kDefaultPointerDeviceId, 0))
187  .Times(1);
188  EXPECT_CALL(delegate,
189  OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindStylus,
190  kDefaultPointerDeviceId, 0))
191  .Times(1);
192 
193  // Down
194  EXPECT_CALL(
195  delegate,
196  OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindMouse,
197  kDefaultPointerDeviceId, kFlutterPointerButtonMousePrimary))
198  .Times(1);
199  EXPECT_CALL(
200  delegate,
201  OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindTouch,
202  kDefaultPointerDeviceId, kFlutterPointerButtonMousePrimary))
203  .Times(1);
204  EXPECT_CALL(
205  delegate,
206  OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindStylus,
207  kDefaultPointerDeviceId, kFlutterPointerButtonMousePrimary))
208  .Times(1);
209 
210  // Up
211  EXPECT_CALL(delegate, OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindMouse,
212  kDefaultPointerDeviceId,
213  kFlutterPointerButtonMousePrimary))
214  .Times(1);
215  EXPECT_CALL(delegate, OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindTouch,
216  kDefaultPointerDeviceId,
217  kFlutterPointerButtonMousePrimary))
218  .Times(1);
219  EXPECT_CALL(delegate, OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindStylus,
220  kDefaultPointerDeviceId,
221  kFlutterPointerButtonMousePrimary))
222  .Times(1);
223 
224  // Leave
225  EXPECT_CALL(delegate,
226  OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindMouse,
227  kDefaultPointerDeviceId))
228  .Times(1);
229  EXPECT_CALL(delegate,
230  OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindTouch,
231  kDefaultPointerDeviceId))
232  .Times(1);
233  EXPECT_CALL(delegate,
234  OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindStylus,
235  kDefaultPointerDeviceId))
236  .Times(1);
237 
238  win32window.OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindMouse,
239  kDefaultPointerDeviceId, 0);
240  win32window.OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindMouse,
241  kDefaultPointerDeviceId, WM_LBUTTONDOWN);
242  win32window.OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindMouse,
243  kDefaultPointerDeviceId, WM_LBUTTONDOWN);
244  win32window.OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindMouse,
245  kDefaultPointerDeviceId);
246 
247  // Touch
248  win32window.OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindTouch,
249  kDefaultPointerDeviceId, 0);
250  win32window.OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindTouch,
251  kDefaultPointerDeviceId, WM_LBUTTONDOWN);
252  win32window.OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindTouch,
253  kDefaultPointerDeviceId, WM_LBUTTONDOWN);
254  win32window.OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindTouch,
255  kDefaultPointerDeviceId);
256 
257  // Pen
258  win32window.OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindStylus,
259  kDefaultPointerDeviceId, 0);
260  win32window.OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindStylus,
261  kDefaultPointerDeviceId, WM_LBUTTONDOWN);
262  win32window.OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindStylus,
263  kDefaultPointerDeviceId, WM_LBUTTONDOWN);
264  win32window.OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindStylus,
265  kDefaultPointerDeviceId);
266 
267  // Destruction of win32window sends a HIDE update. In situ, the window is
268  // owned by the delegate, and so is destructed first. Not so here.
269  win32window.SetView(nullptr);
270 }

References flutter::FlutterWindow::OnPointerDown(), flutter::FlutterWindow::OnPointerLeave(), flutter::FlutterWindow::OnPointerMove(), flutter::FlutterWindow::OnPointerUp(), and flutter::FlutterWindow::SetView().

◆ TEST_F() [77/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnScrollCallsGetScrollOffsetMultiplier   
)

Definition at line 274 of file flutter_window_unittests.cc.

274  {
275  MockFlutterWindow win32window;
276  MockWindowBindingHandlerDelegate delegate;
277  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
278  win32window.SetView(&delegate);
279 
280  EXPECT_CALL(win32window, GetWindowHandle).WillOnce([&win32window]() {
281  return win32window.FlutterWindow::GetWindowHandle();
282  });
283  EXPECT_CALL(win32window, GetScrollOffsetMultiplier).WillOnce(Return(120.0f));
284 
285  EXPECT_CALL(delegate,
286  OnScroll(_, _, 0, 0, 120.0f, kFlutterPointerDeviceKindMouse,
287  kDefaultPointerDeviceId))
288  .Times(1);
289 
290  win32window.OnScroll(0.0f, 0.0f, kFlutterPointerDeviceKindMouse,
291  kDefaultPointerDeviceId);
292 }

◆ TEST_F() [78/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnThemeChange   
)

Definition at line 305 of file flutter_window_unittests.cc.

305  {
306  MockFlutterWindow win32window;
307  MockWindowBindingHandlerDelegate delegate;
308  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
309  win32window.SetView(&delegate);
310 
311  EXPECT_CALL(delegate, OnHighContrastChanged).Times(1);
312 
313  win32window.InjectWindowMessage(WM_THEMECHANGED, 0, 0);
314 }

◆ TEST_F() [79/192]

flutter::testing::TEST_F ( FlutterWindowTest  ,
OnWindowRepaint   
)

Definition at line 294 of file flutter_window_unittests.cc.

294  {
295  MockFlutterWindow win32window;
296  MockWindowBindingHandlerDelegate delegate;
297  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
298  win32window.SetView(&delegate);
299 
300  EXPECT_CALL(delegate, OnWindowRepaint()).Times(1);
301 
302  win32window.InjectWindowMessage(WM_PAINT, 0, 0);
303 }

◆ TEST_F() [80/192]

flutter::testing::TEST_F ( KeyboardTest  ,
AltGrModifiedKey   
)

Definition at line 1278 of file keyboard_unittests.cc.

1278  {
1279  KeyboardTester tester{GetContext()};
1280  tester.Responding(false);
1281 
1282  // German Keyboard layout
1283 
1284  // Press AltGr, which Win32 precedes with a ContrlLeft down.
1285  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1286  KeyStateChange{VK_LCONTROL, true, true},
1287  WmKeyDownInfo{VK_LCONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1288  kWmResultZero),
1289  KeyStateChange{VK_RMENU, true, true},
1290  WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1291  kWmResultZero)});
1292 
1293  EXPECT_EQ(tester.key_calls.size(), 2);
1294  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1295  kPhysicalControlLeft, kLogicalControlLeft, "",
1296  kNotSynthesized);
1297  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1298  kPhysicalAltRight, kLogicalAltRight, "",
1299  kNotSynthesized);
1300  tester.clear_key_calls();
1301  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1302 
1303  // Press Q
1304  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1305  WmKeyDownInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
1306  kWmResultZero),
1307  WmCharInfo{'@', kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
1308  kWmResultZero)});
1309 
1310  EXPECT_EQ(tester.key_calls.size(), 2);
1311  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1312  kPhysicalKeyQ, kLogicalKeyQ, "@", kNotSynthesized);
1313  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"@");
1314  tester.clear_key_calls();
1315  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1316 
1317  // Release Q
1318  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1319  WmKeyUpInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended}.Build(
1320  kWmResultZero)});
1321 
1322  EXPECT_EQ(tester.key_calls.size(), 1);
1323  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1324  kPhysicalKeyQ, kLogicalKeyQ, "", kNotSynthesized);
1325  tester.clear_key_calls();
1326  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1327 
1328  // Release AltGr. Win32 doesn't dispatch ControlLeft up. Instead Flutter will
1329  // forge one. The AltGr is a system key, therefore will be handled by Win32's
1330  // default WndProc.
1331  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1332  KeyStateChange{VK_LCONTROL, false, true},
1333  ExpectForgedMessage{
1334  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1335  kWmResultZero)},
1336  KeyStateChange{VK_RMENU, false, true},
1337  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1338  kWmResultDefault)});
1339 
1340  EXPECT_EQ(tester.key_calls.size(), 2);
1341  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1342  kPhysicalControlLeft, kLogicalControlLeft, "",
1343  kNotSynthesized);
1344  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1345  kPhysicalAltRight, kLogicalAltRight, "",
1346  kNotSynthesized);
1347  tester.clear_key_calls();
1348  // The sys key up must not be redispatched. The forged ControlLeft up will.
1349  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1350 }
EXPECT_CALL_IS_TEXT
#define EXPECT_CALL_IS_TEXT(_key_call, u16_string)
Definition: keyboard_unittests.cc:564
EXPECT_CALL_IS_EVENT
#define EXPECT_CALL_IS_EVENT(_key_call, _type, _physical, _logical, _character, _synthesized)
Definition: keyboard_unittests.cc:558

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [81/192]

flutter::testing::TEST_F ( KeyboardTest  ,
AltGrTwice   
)

Definition at line 1365 of file keyboard_unittests.cc.

1365  {
1366  KeyboardTester tester{GetContext()};
1367  tester.Responding(false);
1368 
1369  // 1. AltGr down.
1370 
1371  // The key down event causes a ControlLeft down and a AltRight (extended
1372  // AltLeft) down.
1373  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1374  KeyStateChange{VK_LCONTROL, true, true},
1375  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1376  kWmResultZero),
1377  KeyStateChange{VK_RMENU, true, true},
1378  WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1379  kWmResultZero)});
1380 
1381  EXPECT_EQ(tester.key_calls.size(), 2);
1382  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1383  kPhysicalControlLeft, kLogicalControlLeft, "",
1384  kNotSynthesized);
1385  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1386  kPhysicalAltRight, kLogicalAltRight, "",
1387  kNotSynthesized);
1388  tester.clear_key_calls();
1389  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1390 
1391  // 2. AltGr up.
1392 
1393  // The key up event only causes a AltRight (extended AltLeft) up.
1394  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1395  KeyStateChange{VK_LCONTROL, false, true},
1396  ExpectForgedMessage{
1397  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1398  kWmResultZero)},
1399  KeyStateChange{VK_RMENU, false, true},
1400  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1401  kWmResultDefault)});
1402  EXPECT_EQ(tester.key_calls.size(), 2);
1403  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1404  kPhysicalControlLeft, kLogicalControlLeft, "",
1405  kNotSynthesized);
1406  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1407  kPhysicalAltRight, kLogicalAltRight, "",
1408  kNotSynthesized);
1409  tester.clear_key_calls();
1410  // The sys key up must not be redispatched. The forged ControlLeft up will.
1411  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1412 
1413  // 3. AltGr down (or: ControlLeft down then AltRight down.)
1414 
1415  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1416  KeyStateChange{VK_LCONTROL, true, false},
1417  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1418  kWmResultZero),
1419  KeyStateChange{VK_RMENU, true, true},
1420  WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1421  kWmResultZero)});
1422 
1423  EXPECT_EQ(tester.key_calls.size(), 2);
1424  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1425  kPhysicalControlLeft, kLogicalControlLeft, "",
1426  kNotSynthesized);
1427  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1428  kPhysicalAltRight, kLogicalAltRight, "",
1429  kNotSynthesized);
1430  tester.clear_key_calls();
1431  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1432 
1433  // 4. AltGr up.
1434 
1435  // The key up event only causes a AltRight (extended AltLeft) up.
1436  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1437  KeyStateChange{VK_LCONTROL, false, false},
1438  ExpectForgedMessage{
1439  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1440  kWmResultZero)},
1441  KeyStateChange{VK_RMENU, false, false},
1442  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1443  kWmResultDefault)});
1444  EXPECT_EQ(tester.key_calls.size(), 2);
1445  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1446  kPhysicalControlLeft, kLogicalControlLeft, "",
1447  kNotSynthesized);
1448  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1449  kPhysicalAltRight, kLogicalAltRight, "",
1450  kNotSynthesized);
1451  tester.clear_key_calls();
1452  // The sys key up must not be redispatched. The forged ControlLeft up will.
1453  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1454 
1455  // 5. For key sequence 2: a real ControlLeft up.
1456  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1457  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1458  kWmResultZero)});
1459  EXPECT_EQ(tester.key_calls.size(), 1);
1460  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
1461  kNotSynthesized);
1462  tester.clear_key_calls();
1463  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
1464 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [82/192]

flutter::testing::TEST_F ( KeyboardTest  ,
AltLeftUnhandled   
)

Definition at line 841 of file keyboard_unittests.cc.

841  {
842  KeyboardTester tester{GetContext()};
843  tester.Responding(false);
844 
845  // US Keyboard layout
846 
847  // Press AltLeft. AltLeft is a SysKeyDown event.
848  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
849  KeyStateChange{VK_LMENU, true, false},
850  WmSysKeyDownInfo{VK_MENU, kScanCodeAlt, kNotExtended, kWasUp}.Build(
851  kWmResultDefault)}); // Always pass to the default WndProc.
852 
853  EXPECT_EQ(tester.key_calls.size(), 1);
854  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
855  kPhysicalAltLeft, kLogicalAltLeft, "", kNotSynthesized);
856  tester.clear_key_calls();
857  // Don't redispatch sys messages.
858  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
859 
860  // Release AltLeft. AltLeft is a SysKeyUp event.
861  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
862  KeyStateChange{VK_LMENU, false, true},
863  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kNotExtended}.Build(
864  kWmResultDefault)}); // Always pass to the default WndProc.
865 
866  EXPECT_EQ(tester.key_calls.size(), 1);
867  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
868  kPhysicalAltLeft, kLogicalAltLeft, "", kNotSynthesized);
869  tester.clear_key_calls();
870  // Don't redispatch sys messages.
871  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
872 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [83/192]

flutter::testing::TEST_F ( KeyboardTest  ,
AltRightUnhandled   
)

Definition at line 874 of file keyboard_unittests.cc.

874  {
875  KeyboardTester tester{GetContext()};
876  tester.Responding(false);
877 
878  // US Keyboard layout
879 
880  // Press AltRight. AltRight is a SysKeyDown event.
881  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
882  KeyStateChange{VK_RMENU, true, false},
883  WmSysKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
884  kWmResultDefault)}); // Always pass to the default WndProc.
885 
886  EXPECT_EQ(tester.key_calls.size(), 1);
887  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
888  kPhysicalAltRight, kLogicalAltRight, "",
889  kNotSynthesized);
890  tester.clear_key_calls();
891  // Don't redispatch sys messages.
892  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
893 
894  // Release AltRight. AltRight is a SysKeyUp event.
895  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
896  KeyStateChange{VK_RMENU, false, true},
897  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
898  kWmResultDefault)}); // Always pass to the default WndProc.
899 
900  EXPECT_EQ(tester.key_calls.size(), 1);
901  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
902  kPhysicalAltRight, kLogicalAltRight, "",
903  kNotSynthesized);
904  tester.clear_key_calls();
905  // Don't redispatch sys messages.
906  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
907 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [84/192]

flutter::testing::TEST_F ( KeyboardTest  ,
ArrowLeftHandled   
)

Definition at line 635 of file keyboard_unittests.cc.

635  {
636  KeyboardTester tester{GetContext()};
637  tester.Responding(true);
638 
639  // US Keyboard layout
640 
641  // Press ArrowLeft
642  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
643  WmKeyDownInfo{VK_LEFT, kScanCodeArrowLeft, kExtended, kWasUp}.Build(
644  kWmResultZero)});
645 
646  EXPECT_EQ(tester.key_calls.size(), 1);
647  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
648  kPhysicalArrowLeft, kLogicalArrowLeft, "",
649  kNotSynthesized);
650  tester.clear_key_calls();
651  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
652 
653  // Release ArrowLeft
654  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
655  WmKeyUpInfo{VK_LEFT, kScanCodeArrowLeft, kExtended}.Build(
656  kWmResultZero)});
657 
658  EXPECT_EQ(tester.key_calls.size(), 1);
659  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
660  kPhysicalArrowLeft, kLogicalArrowLeft, "",
661  kNotSynthesized);
662  tester.clear_key_calls();
663  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
664 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [85/192]

flutter::testing::TEST_F ( KeyboardTest  ,
ArrowLeftUnhandled   
)

Definition at line 666 of file keyboard_unittests.cc.

666  {
667  KeyboardTester tester{GetContext()};
668  tester.Responding(false);
669 
670  // US Keyboard layout
671 
672  // Press ArrowLeft
673  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
674  WmKeyDownInfo{VK_LEFT, kScanCodeArrowLeft, kExtended, kWasUp}.Build(
675  kWmResultZero)});
676 
677  EXPECT_EQ(tester.key_calls.size(), 1);
678  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
679  kPhysicalArrowLeft, kLogicalArrowLeft, "",
680  kNotSynthesized);
681  tester.clear_key_calls();
682  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
683 
684  // Release ArrowLeft
685  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
686  WmKeyUpInfo{VK_LEFT, kScanCodeArrowLeft, kExtended}.Build(
687  kWmResultZero)});
688 
689  EXPECT_EQ(tester.key_calls.size(), 1);
690  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
691  kPhysicalArrowLeft, kLogicalArrowLeft, "",
692  kNotSynthesized);
693  tester.clear_key_calls();
694  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
695 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [86/192]

flutter::testing::TEST_F ( KeyboardTest  ,
CtrlLeftDigit1   
)

Definition at line 1188 of file keyboard_unittests.cc.

1188  {
1189  KeyboardTester tester{GetContext()};
1190  tester.Responding(false);
1191 
1192  // US Keyboard layout
1193 
1194  // Press ControlLeft
1195  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1196  KeyStateChange{VK_LCONTROL, true, true},
1197  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1198  kWmResultZero)});
1199 
1200  EXPECT_EQ(tester.key_calls.size(), 1);
1201  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1202  kPhysicalControlLeft, kLogicalControlLeft, "",
1203  kNotSynthesized);
1204  tester.clear_key_calls();
1205  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1206 
1207  // Press 1
1208  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1209  WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1210  .Build(kWmResultZero)});
1211 
1212  EXPECT_EQ(tester.key_calls.size(), 1);
1213  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1214  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1215  tester.clear_key_calls();
1216  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1217 
1218  // Release 1
1219  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1220  WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1221  kWmResultZero)});
1222 
1223  EXPECT_EQ(tester.key_calls.size(), 1);
1224  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1225  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1226  tester.clear_key_calls();
1227  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1228 
1229  // Release ControlLeft
1230  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1231  KeyStateChange{VK_LCONTROL, false, true},
1232  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1233  kWmResultZero)});
1234 
1235  EXPECT_EQ(tester.key_calls.size(), 1);
1236  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1237  kPhysicalControlLeft, kLogicalControlLeft, "",
1238  kNotSynthesized);
1239  tester.clear_key_calls();
1240  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1241 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [87/192]

flutter::testing::TEST_F ( KeyboardTest  ,
CtrlLeftKeyA   
)

Definition at line 1130 of file keyboard_unittests.cc.

1130  {
1131  KeyboardTester tester{GetContext()};
1132  tester.Responding(false);
1133 
1134  // US Keyboard layout
1135 
1136  // Press ControlLeft
1137  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1138  KeyStateChange{VK_LCONTROL, true, true},
1139  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1140  kWmResultZero)});
1141 
1142  EXPECT_EQ(tester.key_calls.size(), 1);
1143  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1144  kPhysicalControlLeft, kLogicalControlLeft, "",
1145  kNotSynthesized);
1146  tester.clear_key_calls();
1147  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1148 
1149  // Press A
1150  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1151  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1152  kWmResultZero),
1153  WmCharInfo{0x01, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1154  kWmResultZero)});
1155 
1156  EXPECT_EQ(tester.key_calls.size(), 1);
1157  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1158  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1159  tester.clear_key_calls();
1160  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1161 
1162  // Release A
1163  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1164  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
1165  kWmResultZero)});
1166 
1167  EXPECT_EQ(tester.key_calls.size(), 1);
1168  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1169  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1170  tester.clear_key_calls();
1171  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1172 
1173  // Release ControlLeft
1174  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1175  KeyStateChange{VK_LCONTROL, false, true},
1176  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1177  kWmResultZero)});
1178 
1179  EXPECT_EQ(tester.key_calls.size(), 1);
1180  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1181  kPhysicalControlLeft, kLogicalControlLeft, "",
1182  kNotSynthesized);
1183  tester.clear_key_calls();
1184  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1185 }

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [88/192]

flutter::testing::TEST_F ( KeyboardTest  ,
CtrlLeftUnhandled   
)

Definition at line 775 of file keyboard_unittests.cc.

775  {
776  KeyboardTester tester{GetContext()};
777  tester.Responding(false);
778 
779  // US Keyboard layout
780 
781  // Press CtrlLeft
782  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
783  KeyStateChange{VK_LCONTROL, true, false},
784  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
785  kWmResultZero)});
786 
787  EXPECT_EQ(tester.key_calls.size(), 1);
788  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
789  kPhysicalControlLeft, kLogicalControlLeft, "",
790  kNotSynthesized);
791  tester.clear_key_calls();
792  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
793 
794  // Release CtrlLeft
795  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
796  KeyStateChange{VK_LCONTROL, false, true},
797  WmKeyUpInfo{VK_SHIFT, kScanCodeControl, kNotExtended}.Build(
798  kWmResultZero)});
799 
800  EXPECT_EQ(tester.key_calls.size(), 1);
801  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
802  kPhysicalControlLeft, kLogicalControlLeft, "",
803  kNotSynthesized);
804  tester.clear_key_calls();
805  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
806 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [89/192]

flutter::testing::TEST_F ( KeyboardTest  ,
CtrlRightUnhandled   
)

Definition at line 808 of file keyboard_unittests.cc.

808  {
809  KeyboardTester tester{GetContext()};
810  tester.Responding(false);
811 
812  // US Keyboard layout
813 
814  // Press CtrlRight
815  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
816  KeyStateChange{VK_RCONTROL, true, false},
817  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kExtended, kWasUp}.Build(
818  kWmResultZero)});
819 
820  EXPECT_EQ(tester.key_calls.size(), 1);
821  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
822  kPhysicalControlRight, kLogicalControlRight, "",
823  kNotSynthesized);
824  tester.clear_key_calls();
825  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
826 
827  // Release CtrlRight
828  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
829  KeyStateChange{VK_RCONTROL, false, true},
830  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kExtended}.Build(
831  kWmResultZero)});
832 
833  EXPECT_EQ(tester.key_calls.size(), 1);
834  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
835  kPhysicalControlRight, kLogicalControlRight, "",
836  kNotSynthesized);
837  tester.clear_key_calls();
838  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
839 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [90/192]

flutter::testing::TEST_F ( KeyboardTest  ,
DeadKeyThatCombines   
)

Definition at line 1468 of file keyboard_unittests.cc.

1468  {
1469  KeyboardTester tester{GetContext()};
1470  tester.Responding(false);
1471 
1472  tester.SetLayout(LayoutFrench);
1473 
1474  // Press ^¨ (US: Left bracket)
1475  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1476  WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1477  kWmResultZero),
1478  WmDeadCharInfo{'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1479  kWmResultZero)});
1480 
1481  EXPECT_EQ(tester.key_calls.size(), 1);
1482  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1483  kPhysicalBracketLeft, kLogicalBracketRight, "^",
1484  kNotSynthesized);
1485  tester.clear_key_calls();
1486  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1487 
1488  // Release ^¨
1489  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1490  WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
1491  kWmResultZero)});
1492 
1493  EXPECT_EQ(tester.key_calls.size(), 1);
1494  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1495  kPhysicalBracketLeft, kLogicalBracketRight, "",
1496  kNotSynthesized);
1497  tester.clear_key_calls();
1498  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1499 
1500  // Press E
1501  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1502  WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1503  kWmResultZero),
1504  WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1505  kWmResultZero)});
1506 
1507  EXPECT_EQ(tester.key_calls.size(), 2);
1508  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1509  kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
1510  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"ê");
1511  tester.clear_key_calls();
1512  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1513 
1514  // Release E
1515  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1516  WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
1517  kWmResultZero)});
1518 
1519  EXPECT_EQ(tester.key_calls.size(), 1);
1520  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1521  kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
1522  tester.clear_key_calls();
1523  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1524 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [91/192]

flutter::testing::TEST_F ( KeyboardTest  ,
DeadKeyThatDoesNotCombine   
)

Definition at line 1612 of file keyboard_unittests.cc.

1612  {
1613  KeyboardTester tester{GetContext()};
1614  tester.Responding(false);
1615 
1616  tester.SetLayout(LayoutFrench);
1617 
1618  // Press ^¨ (US: Left bracket)
1619  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1620  WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1621  kWmResultZero),
1622  WmDeadCharInfo{'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1623  kWmResultZero)});
1624 
1625  EXPECT_EQ(tester.key_calls.size(), 1);
1626  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1627  kPhysicalBracketLeft, kLogicalBracketRight, "^",
1628  kNotSynthesized);
1629  tester.clear_key_calls();
1630  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1631 
1632  // Release ^¨
1633  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1634  WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
1635  kWmResultZero)});
1636 
1637  EXPECT_EQ(tester.key_calls.size(), 1);
1638  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1639  kPhysicalBracketLeft, kLogicalBracketRight, "",
1640  kNotSynthesized);
1641  tester.clear_key_calls();
1642  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1643 
1644  // Press 1
1645  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1646  WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1647  .Build(kWmResultZero),
1648  WmCharInfo{'^', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1649  kWmResultZero),
1650  WmCharInfo{'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1651  kWmResultZero)});
1652 
1653  EXPECT_EQ(tester.key_calls.size(), 3);
1654  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1655  kPhysicalDigit1, kLogicalDigit1, "^", kNotSynthesized);
1656  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"^");
1657  EXPECT_CALL_IS_TEXT(tester.key_calls[2], u"&");
1658  tester.clear_key_calls();
1659  // TODO(dkwingsmt): This count should probably be 3. Currently the '^'
1660  // message is redispatched due to being part of the KeyDown session, which is
1661  // not handled by the framework, while the '&' message is not redispatched
1662  // for being a standalone message. We should resolve this inconsistency.
1663  // https://github.com/flutter/flutter/issues/98306
1664  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1665 
1666  // Release 1
1667  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1668  WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1669  kWmResultZero)});
1670 
1671  EXPECT_EQ(tester.key_calls.size(), 1);
1672  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1673  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1674  tester.clear_key_calls();
1675  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1676 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [92/192]

flutter::testing::TEST_F ( KeyboardTest  ,
DeadKeyTwiceThenLetter   
)

Definition at line 1681 of file keyboard_unittests.cc.

1681  {
1682  KeyboardTester tester{GetContext()};
1683  tester.Responding(false);
1684 
1685  // US INTL layout.
1686 
1687  // Press `
1688  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1689  WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1690  kWmResultZero),
1691  WmDeadCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1692  kWmResultZero)});
1693 
1694  EXPECT_EQ(tester.key_calls.size(), 1);
1695  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1696  kPhysicalBackquote, kLogicalBackquote, "`",
1697  kNotSynthesized);
1698  tester.clear_key_calls();
1699  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1700 
1701  // Release `
1702  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1703  WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
1704  kWmResultZero)});
1705 
1706  EXPECT_EQ(tester.key_calls.size(), 1);
1707  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1708  kPhysicalBackquote, kLogicalBackquote, "",
1709  kNotSynthesized);
1710  tester.clear_key_calls();
1711  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1712 
1713  // Press ` again.
1714  // The response should be slow.
1715  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
1716  tester.LateResponding(
1717  [&recorded_callbacks](
1718  const FlutterKeyEvent* event,
1719  MockKeyResponseController::ResponseCallback callback) {
1720  recorded_callbacks.push_back(callback);
1721  });
1722 
1723  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1724  WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1725  kWmResultZero),
1726  WmCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp, kBeingReleased,
1727  kNoContext, 1, /*bit25*/ true}
1728  .Build(kWmResultZero),
1729  WmCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1730  kWmResultZero)});
1731 
1732  EXPECT_EQ(recorded_callbacks.size(), 1);
1733  EXPECT_EQ(tester.key_calls.size(), 1);
1734  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1735  kPhysicalBackquote, kLogicalBackquote, "`",
1736  kNotSynthesized);
1737  tester.clear_key_calls();
1738  // Key down event responded with false.
1739  recorded_callbacks.front()(false);
1740  EXPECT_EQ(tester.key_calls.size(), 2);
1741  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"`");
1742  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"`");
1743  tester.clear_key_calls();
1744  // TODO(dkwingsmt): This count should probably be 3. See the comment above
1745  // that is marked with the same issue.
1746  // https://github.com/flutter/flutter/issues/98306
1747  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1748 
1749  tester.Responding(false);
1750 
1751  // Release `
1752  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1753  WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
1754  kWmResultZero)});
1755 
1756  EXPECT_EQ(tester.key_calls.size(), 1);
1757  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1758  kPhysicalBackquote, kLogicalBackquote, "",
1759  kNotSynthesized);
1760  tester.clear_key_calls();
1761  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1762 }

References callback, EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [93/192]

flutter::testing::TEST_F ( KeyboardTest  ,
DeadKeyWithoutDeadMaskThatCombines   
)

Definition at line 1531 of file keyboard_unittests.cc.

1531  {
1532  KeyboardTester tester{GetContext()};
1533  tester.Responding(false);
1534 
1535  // Press ShiftLeft
1536  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1537  KeyStateChange{VK_LSHIFT, true, true},
1538  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
1539  kWmResultZero)});
1540 
1541  EXPECT_EQ(tester.key_calls.size(), 1);
1542  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1543  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1544  kNotSynthesized);
1545  tester.clear_key_calls();
1546  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1547 
1548  // Press 6^
1549  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1550  WmKeyDownInfo{'6', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
1551  kWmResultZero),
1552  WmDeadCharInfo{'^', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
1553  kWmResultZero)});
1554 
1555  EXPECT_EQ(tester.key_calls.size(), 1);
1556  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1557  kPhysicalDigit6, kLogicalDigit6, "6", kNotSynthesized);
1558  tester.clear_key_calls();
1559  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1560 
1561  // Release 6^
1562  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1563  WmKeyUpInfo{'6', kScanCodeDigit6, kNotExtended}.Build(kWmResultZero)});
1564 
1565  EXPECT_EQ(tester.key_calls.size(), 1);
1566  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1567  kPhysicalDigit6, kLogicalDigit6, "", kNotSynthesized);
1568  tester.clear_key_calls();
1569  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1570 
1571  // Release ShiftLeft
1572  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1573  KeyStateChange{VK_LSHIFT, false, true},
1574  WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
1575  kWmResultZero)});
1576 
1577  EXPECT_EQ(tester.key_calls.size(), 1);
1578  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1579  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1580  kNotSynthesized);
1581  tester.clear_key_calls();
1582  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1583 
1584  // Press E
1585  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1586  WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1587  kWmResultZero),
1588  WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1589  kWmResultZero)});
1590 
1591  EXPECT_EQ(tester.key_calls.size(), 2);
1592  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1593  kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
1594  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"ê");
1595  tester.clear_key_calls();
1596  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1597 
1598  // Release E
1599  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1600  WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
1601  kWmResultZero)});
1602 
1603  EXPECT_EQ(tester.key_calls.size(), 1);
1604  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1605  kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
1606  tester.clear_key_calls();
1607  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1608 }

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [94/192]

flutter::testing::TEST_F ( KeyboardTest  ,
Digit1OnFrenchLayout   
)

Definition at line 1245 of file keyboard_unittests.cc.

1245  {
1246  KeyboardTester tester{GetContext()};
1247  tester.Responding(false);
1248 
1249  tester.SetLayout(LayoutFrench);
1250 
1251  // Press 1
1252  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1253  WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1254  .Build(kWmResultZero),
1255  WmCharInfo{'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1256  kWmResultZero)});
1257 
1258  EXPECT_EQ(tester.key_calls.size(), 2);
1259  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1260  kPhysicalDigit1, kLogicalDigit1, "&", kNotSynthesized);
1261  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"&");
1262  tester.clear_key_calls();
1263  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1264 
1265  // Release 1
1266  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1267  WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1268  kWmResultZero)});
1269 
1270  EXPECT_EQ(tester.key_calls.size(), 1);
1271  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1272  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1273  tester.clear_key_calls();
1274  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1275 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [95/192]

flutter::testing::TEST_F ( KeyboardTest  ,
DoubleCapsLock   
)

Definition at line 2504 of file keyboard_unittests.cc.

2504  {
2505  KeyboardTester tester{GetContext()};
2506  tester.Responding(false);
2507 
2508  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2509  WmKeyDownInfo{VK_CAPITAL, 0, kNotExtended}.Build(),
2510  WmKeyUpInfo{VK_CAPITAL, 0, kNotExtended}.Build()});
2511 
2512  tester.clear_key_calls();
2513 }

◆ TEST_F() [96/192]

flutter::testing::TEST_F ( KeyboardTest  ,
FreshKeyDownAfterMissedUpIsDelivered   
)

Definition at line 1036 of file keyboard_unittests.cc.

1036  {
1037  KeyboardTester tester{GetContext()};
1038  tester.Responding(true);
1039 
1040  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1041  WmKeyDownInfo{VK_RETURN, kScanCodeEnter, kNotExtended, kWasUp}.Build(
1042  kWmResultZero)});
1043 
1044  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1045  WmKeyDownInfo{VK_RETURN, kScanCodeEnter, kNotExtended, kWasUp}.Build(
1046  kWmResultZero)});
1047 
1048  ASSERT_EQ(tester.key_calls.size(), 3u);
1049  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1050  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
1051  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1052  kPhysicalEnter, kLogicalEnter, "", kSynthesized);
1053  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeDown,
1054  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
1055  tester.clear_key_calls();
1056 
1057  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1058  WmKeyUpInfo{VK_RETURN, kScanCodeEnter, kNotExtended}.Build(
1059  kWmResultZero)});
1060 
1061  ASSERT_EQ(tester.key_calls.size(), 1u);
1062  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1063  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
1064  tester.clear_key_calls();
1065  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0u);
1066 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [97/192]

flutter::testing::TEST_F ( KeyboardTest  ,
ImeExtendedEventsAreIgnored   
)

Definition at line 2030 of file keyboard_unittests.cc.

2030  {
2031  KeyboardTester tester{GetContext()};
2032  tester.Responding(false);
2033 
2034  // US Keyboard layout.
2035 
2036  // There should be preceding key events to make the keyboard into IME mode.
2037  // Omit them in this test since they are not relavent.
2038 
2039  // Press CtrlRight in IME mode.
2040  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2041  KeyStateChange{VK_RCONTROL, true, false},
2042  WmKeyDownInfo{VK_PROCESSKEY, kScanCodeControl, kExtended, kWasUp}.Build(
2043  kWmResultZero)});
2044 
2045  EXPECT_EQ(tester.key_calls.size(), 1);
2046  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2047  kNotSynthesized);
2048  tester.clear_key_calls();
2049  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2050 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [98/192]

flutter::testing::TEST_F ( KeyboardTest  ,
LowerCaseAHandled   
)

Definition at line 572 of file keyboard_unittests.cc.

572  {
573  KeyboardTester tester{GetContext()};
574  tester.Responding(true);
575 
576  // US Keyboard layout
577 
578  // Press A
579  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
580  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
581  kWmResultZero),
582  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
583  kWmResultZero)});
584 
585  EXPECT_EQ(tester.key_calls.size(), 1);
586  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
587  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
588  tester.clear_key_calls();
589  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
590 
591  // Release A
592  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
593  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
594  kWmResultZero)});
595 
596  EXPECT_EQ(tester.key_calls.size(), 1);
597  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
598  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
599  tester.clear_key_calls();
600  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
601 }

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [99/192]

flutter::testing::TEST_F ( KeyboardTest  ,
LowerCaseAUnhandled   
)

Definition at line 603 of file keyboard_unittests.cc.

603  {
604  KeyboardTester tester{GetContext()};
605  tester.Responding(false);
606 
607  // US Keyboard layout
608 
609  // Press A
610  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
611  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
612  kWmResultZero),
613  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
614  kWmResultZero)});
615 
616  EXPECT_EQ(tester.key_calls.size(), 2);
617  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
618  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
619  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
620  tester.clear_key_calls();
621  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
622 
623  // Release A
624  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
625  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
626  kWmResultZero)});
627 
628  EXPECT_EQ(tester.key_calls.size(), 1);
629  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
630  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
631  tester.clear_key_calls();
632  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
633 }

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [100/192]

flutter::testing::TEST_F ( KeyboardTest  ,
MetaLeftUnhandled   
)

Definition at line 909 of file keyboard_unittests.cc.

909  {
910  KeyboardTester tester{GetContext()};
911  tester.Responding(false);
912 
913  // US Keyboard layout
914 
915  // Press MetaLeft
916  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
917  KeyStateChange{VK_LWIN, true, false},
918  WmKeyDownInfo{VK_LWIN, kScanCodeMetaLeft, kExtended, kWasUp}.Build(
919  kWmResultZero)});
920 
921  EXPECT_EQ(tester.key_calls.size(), 1);
922  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
923  kPhysicalMetaLeft, kLogicalMetaLeft, "",
924  kNotSynthesized);
925  tester.clear_key_calls();
926  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
927 
928  // Release MetaLeft
929  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
930  KeyStateChange{VK_LWIN, false, true},
931  WmKeyUpInfo{VK_LWIN, kScanCodeMetaLeft, kExtended}.Build(kWmResultZero)});
932 
933  EXPECT_EQ(tester.key_calls.size(), 1);
934  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
935  kPhysicalMetaLeft, kLogicalMetaLeft, "",
936  kNotSynthesized);
937  tester.clear_key_calls();
938  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
939 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [101/192]

flutter::testing::TEST_F ( KeyboardTest  ,
MetaRightUnhandled   
)

Definition at line 941 of file keyboard_unittests.cc.

941  {
942  KeyboardTester tester{GetContext()};
943  tester.Responding(false);
944 
945  // US Keyboard layout
946 
947  // Press MetaRight
948  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
949  KeyStateChange{VK_RWIN, true, false},
950  WmKeyDownInfo{VK_RWIN, kScanCodeMetaRight, kExtended, kWasUp}.Build(
951  kWmResultZero)});
952 
953  EXPECT_EQ(tester.key_calls.size(), 1);
954  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
955  kPhysicalMetaRight, kLogicalMetaRight, "",
956  kNotSynthesized);
957  tester.clear_key_calls();
958  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
959 
960  // Release MetaRight
961  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
962  KeyStateChange{VK_RWIN, false, true},
963  WmKeyUpInfo{VK_RWIN, kScanCodeMetaRight, kExtended}.Build(
964  kWmResultZero)});
965 
966  EXPECT_EQ(tester.key_calls.size(), 1);
967  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
968  kPhysicalMetaRight, kLogicalMetaRight, "",
969  kNotSynthesized);
970  tester.clear_key_calls();
971  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
972 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [102/192]

flutter::testing::TEST_F ( KeyboardTest  ,
MultibyteCharacter   
)

Definition at line 1765 of file keyboard_unittests.cc.

1765  {
1766  KeyboardTester tester{GetContext()};
1767  tester.Responding(false);
1768 
1769  // Gothic Keyboard layout. (We need a layout that yields non-BMP characters
1770  // without IME, which is actually very rare.)
1771 
1772  // Press key W of a US keyboard, which should yield character '𐍅'.
1773  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1774  WmKeyDownInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1775  kWmResultZero),
1776  WmCharInfo{0xd800, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1777  kWmResultZero),
1778  WmCharInfo{0xdf45, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1779  kWmResultZero)});
1780 
1781  const char* st = tester.key_calls[0].key_event.character;
1782 
1783  EXPECT_EQ(tester.key_calls.size(), 2);
1784  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1785  kPhysicalKeyW, kLogicalKeyW, "𐍅", kNotSynthesized);
1786  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"𐍅");
1787  tester.clear_key_calls();
1788  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
1789 
1790  // Release W
1791  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1792  WmKeyUpInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended}.Build(
1793  kWmResultZero)});
1794 
1795  EXPECT_EQ(tester.key_calls.size(), 1);
1796  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1797  kPhysicalKeyW, kLogicalKeyW, "", kNotSynthesized);
1798  tester.clear_key_calls();
1799  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1800 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [103/192]

flutter::testing::TEST_F ( KeyboardTest  ,
RepeatA   
)

Definition at line 975 of file keyboard_unittests.cc.

975  {
976  KeyboardTester tester{GetContext()};
977  tester.Responding(true);
978 
979  // Press A
980  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
981  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
982  kWmResultZero),
983  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
984  kWmResultZero)});
985 
986  // Hold A
987  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
988  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
989  kWmResultZero),
990  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
991  kWmResultZero)});
992 
993  EXPECT_EQ(tester.key_calls.size(), 2);
994  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
995  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
996  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeRepeat,
997  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
998  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
999 }

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [104/192]

flutter::testing::TEST_F ( KeyboardTest  ,
RestartClearsKeyboardState   
)

Definition at line 1004 of file keyboard_unittests.cc.

1004  {
1005  KeyboardTester tester{GetContext()};
1006  tester.Responding(true);
1007 
1008  // Press A
1009  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1010  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1011  kWmResultZero),
1012  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1013  kWmResultZero)});
1014 
1015  // Reset the keyboard's state.
1016  tester.ResetKeyboard();
1017 
1018  // Hold A. Notice the message declares the key is already down, however, the
1019  // the keyboard does not send a repeat event as its state was reset.
1020  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1021  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
1022  kWmResultZero),
1023  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
1024  kWmResultZero)});
1025 
1026  EXPECT_EQ(tester.key_calls.size(), 2);
1027  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1028  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
1029  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1030  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
1031  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
1032 }

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [105/192]

flutter::testing::TEST_F ( KeyboardTest  ,
ShiftLeftKeyA   
)

Definition at line 1070 of file keyboard_unittests.cc.

1070  {
1071  KeyboardTester tester{GetContext()};
1072  tester.Responding(false);
1073 
1074  // US Keyboard layout
1075 
1076  // Press ShiftLeft
1077  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1078  KeyStateChange{VK_LSHIFT, true, true},
1079  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
1080  kWmResultZero)});
1081 
1082  EXPECT_EQ(tester.key_calls.size(), 1);
1083  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1084  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1085  kNotSynthesized);
1086  tester.clear_key_calls();
1087  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1088 
1089  // Press A
1090  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1091  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1092  kWmResultZero),
1093  WmCharInfo{'A', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1094  kWmResultZero)});
1095 
1096  EXPECT_EQ(tester.key_calls.size(), 2);
1097  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1098  kPhysicalKeyA, kLogicalKeyA, "A", kNotSynthesized);
1099  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"A");
1100  tester.clear_key_calls();
1101  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1102 
1103  // Release ShiftLeft
1104  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1105  KeyStateChange{VK_LSHIFT, false, true},
1106  WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
1107  kWmResultZero)});
1108 
1109  EXPECT_EQ(tester.key_calls.size(), 1);
1110  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1111  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1112  kNotSynthesized);
1113  tester.clear_key_calls();
1114  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1115 
1116  // Release A
1117  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1118  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
1119  kWmResultZero)});
1120 
1121  EXPECT_EQ(tester.key_calls.size(), 1);
1122  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1123  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1124  tester.clear_key_calls();
1125  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1126 }

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, flutter::kScanCodeShiftLeft, and kVirtualKeyA.

◆ TEST_F() [106/192]

flutter::testing::TEST_F ( KeyboardTest  ,
ShiftLeftUnhandled   
)

Definition at line 697 of file keyboard_unittests.cc.

697  {
698  KeyboardTester tester{GetContext()};
699  tester.Responding(false);
700 
701  // US Keyboard layout
702 
703  // Press ShiftLeft
704  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
705  KeyStateChange{VK_LSHIFT, true, false},
706  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
707  kWmResultZero)});
708 
709  EXPECT_EQ(tester.key_calls.size(), 1);
710  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
711  kPhysicalShiftLeft, kLogicalShiftLeft, "",
712  kNotSynthesized);
713  tester.clear_key_calls();
714  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
715 
716  // Hold ShiftLeft
717  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
718  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasDown}.Build(
719  kWmResultZero)});
720 
721  EXPECT_EQ(tester.key_calls.size(), 1);
722  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeRepeat,
723  kPhysicalShiftLeft, kLogicalShiftLeft, "",
724  kNotSynthesized);
725  tester.clear_key_calls();
726  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
727 
728  // Release ShiftLeft
729  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
730  KeyStateChange{VK_LSHIFT, false, true},
731  WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
732  kWmResultZero)});
733 
734  EXPECT_EQ(tester.key_calls.size(), 1);
735  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
736  kPhysicalShiftLeft, kLogicalShiftLeft, "",
737  kNotSynthesized);
738  tester.clear_key_calls();
739  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
740 }

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [107/192]

flutter::testing::TEST_F ( KeyboardTest  ,
ShiftRightUnhandled   
)

Definition at line 742 of file keyboard_unittests.cc.

742  {
743  KeyboardTester tester{GetContext()};
744  tester.Responding(false);
745 
746  // US Keyboard layout
747 
748  // Press ShiftRight
749  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
750  KeyStateChange{VK_RSHIFT, true, false},
751  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftRight, kNotExtended, kWasUp}.Build(
752  kWmResultZero)});
753 
754  EXPECT_EQ(tester.key_calls.size(), 1);
755  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
756  kPhysicalShiftRight, kLogicalShiftRight, "",
757  kNotSynthesized);
758  tester.clear_key_calls();
759  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
760 
761  // Release ShiftRight
762  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
763  KeyStateChange{VK_RSHIFT, false, true},
764  WmKeyUpInfo{VK_SHIFT, kScanCodeShiftRight, kNotExtended}.Build(
765  kWmResultZero)});
766 
767  EXPECT_EQ(tester.key_calls.size(), 1);
768  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
769  kPhysicalShiftRight, kLogicalShiftRight, "",
770  kNotSynthesized);
771  tester.clear_key_calls();
772  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
773 }

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftRight.

◆ TEST_F() [108/192]

flutter::testing::TEST_F ( KeyboardTest  ,
SlowFrameworkResponse   
)

Definition at line 2097 of file keyboard_unittests.cc.

2097  {
2098  KeyboardTester tester{GetContext()};
2099 
2100  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2101 
2102  // Store callbacks to manually call them.
2103  tester.LateResponding(
2104  [&recorded_callbacks](
2105  const FlutterKeyEvent* event,
2106  MockKeyResponseController::ResponseCallback callback) {
2107  recorded_callbacks.push_back(callback);
2108  });
2109 
2110  // Press A
2111  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2112  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2113  kWmResultZero),
2114  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2115  kWmResultZero)});
2116 
2117  // Hold A
2118  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2119  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
2120  kWmResultZero),
2121  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
2122  kWmResultZero)});
2123 
2124  EXPECT_EQ(tester.key_calls.size(), 1);
2125  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2126  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2127  EXPECT_EQ(recorded_callbacks.size(), 1);
2128  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2129 
2130  // The first response.
2131  recorded_callbacks.front()(false);
2132 
2133  EXPECT_EQ(tester.key_calls.size(), 3);
2134  EXPECT_EQ(recorded_callbacks.size(), 2);
2135  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2136  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeRepeat,
2137  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2138  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2139 
2140  // The second response.
2141  recorded_callbacks.back()(false);
2142 
2143  EXPECT_EQ(tester.key_calls.size(), 4);
2144  EXPECT_CALL_IS_TEXT(tester.key_calls[3], u"a");
2145  tester.clear_key_calls();
2146  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2147 }

References callback, EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [109/192]

flutter::testing::TEST_F ( KeyboardTest  ,
SlowFrameworkResponseForIdenticalEvents   
)

Definition at line 2160 of file keyboard_unittests.cc.

2160  {
2161  KeyboardTester tester{GetContext()};
2162  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2163 
2164  // Store callbacks to manually call them.
2165  tester.LateResponding(
2166  [&recorded_callbacks](
2167  const FlutterKeyEvent* event,
2168  MockKeyResponseController::ResponseCallback callback) {
2169  recorded_callbacks.push_back(callback);
2170  });
2171 
2172  // Press A
2173  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2174  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2175  kWmResultZero),
2176  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2177  kWmResultZero)});
2178 
2179  EXPECT_EQ(tester.key_calls.size(), 1);
2180  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2181  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2182  tester.clear_key_calls();
2183  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2184 
2185  // Release A
2186  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2187  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2188  kWmResultZero)});
2189 
2190  EXPECT_EQ(tester.key_calls.size(), 0);
2191  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2192 
2193  // The first down event responded with false.
2194  EXPECT_EQ(recorded_callbacks.size(), 1);
2195  recorded_callbacks.front()(false);
2196 
2197  EXPECT_EQ(tester.key_calls.size(), 2);
2198  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"a");
2199  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
2200  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2201  tester.clear_key_calls();
2202  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2203 
2204  // Press A again
2205  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2206  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2207  kWmResultZero),
2208  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2209  kWmResultZero)});
2210 
2211  // Nothing more was dispatched because the first up event hasn't been
2212  // responded yet.
2213  EXPECT_EQ(recorded_callbacks.size(), 2);
2214  EXPECT_EQ(tester.key_calls.size(), 0);
2215  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2216 
2217  // The first up event responded with false, which was redispatched, and caused
2218  // the down event to be dispatched.
2219  recorded_callbacks.back()(false);
2220  EXPECT_EQ(tester.key_calls.size(), 1);
2221  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2222  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2223  tester.clear_key_calls();
2224  EXPECT_EQ(recorded_callbacks.size(), 3);
2225  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2226 
2227  // Release A again
2228  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2229  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2230  kWmResultZero)});
2231 
2232  EXPECT_EQ(tester.key_calls.size(), 0);
2233  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2234 }

References callback, EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [110/192]

flutter::testing::TEST_F ( KeyboardTest  ,
SynthesizeModifiers   
)

Definition at line 1802 of file keyboard_unittests.cc.

1802  {
1803  KeyboardTester tester{GetContext()};
1804  tester.Responding(false);
1805 
1806  // Two dummy events used to trigger synthesization.
1807  Win32Message event1 =
1808  WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
1809  kWmResultZero);
1810  Win32Message event2 =
1811  WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
1812  kWmResultZero);
1813 
1814  // ShiftLeft
1815  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1816  KeyStateChange{VK_LSHIFT, true, true}, event1});
1817  EXPECT_EQ(tester.key_calls.size(), 2);
1818  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1819  kPhysicalShiftLeft, kLogicalShiftLeft, "", kSynthesized);
1820  tester.clear_key_calls();
1821  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1822 
1823  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1824  KeyStateChange{VK_LSHIFT, false, true}, event2});
1825  EXPECT_EQ(tester.key_calls.size(), 2);
1826  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1827  kPhysicalShiftLeft, kLogicalShiftLeft, "", kSynthesized);
1828  tester.clear_key_calls();
1829  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1830 
1831  // ShiftRight
1832  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1833  KeyStateChange{VK_RSHIFT, true, true}, event1});
1834  EXPECT_EQ(tester.key_calls.size(), 2);
1835  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1836  kPhysicalShiftRight, kLogicalShiftRight, "",
1837  kSynthesized);
1838  tester.clear_key_calls();
1839  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1840 
1841  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1842  KeyStateChange{VK_RSHIFT, false, true}, event2});
1843  EXPECT_EQ(tester.key_calls.size(), 2);
1844  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1845  kPhysicalShiftRight, kLogicalShiftRight, "",
1846  kSynthesized);
1847  tester.clear_key_calls();
1848  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1849 
1850  // ControlLeft
1851  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1852  KeyStateChange{VK_LCONTROL, true, true}, event1});
1853  EXPECT_EQ(tester.key_calls.size(), 2);
1854  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1855  kPhysicalControlLeft, kLogicalControlLeft, "",
1856  kSynthesized);
1857  tester.clear_key_calls();
1858  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1859 
1860  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1861  KeyStateChange{VK_LCONTROL, false, true}, event2});
1862  EXPECT_EQ(tester.key_calls.size(), 2);
1863  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1864  kPhysicalControlLeft, kLogicalControlLeft, "",
1865  kSynthesized);
1866  tester.clear_key_calls();
1867  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1868 
1869  // ControlRight
1870  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1871  KeyStateChange{VK_RCONTROL, true, true}, event1});
1872  EXPECT_EQ(tester.key_calls.size(), 2);
1873  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1874  kPhysicalControlRight, kLogicalControlRight, "",
1875  kSynthesized);
1876  tester.clear_key_calls();
1877  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1878 
1879  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1880  KeyStateChange{VK_RCONTROL, false, true}, event2});
1881  EXPECT_EQ(tester.key_calls.size(), 2);
1882  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1883  kPhysicalControlRight, kLogicalControlRight, "",
1884  kSynthesized);
1885  tester.clear_key_calls();
1886  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1887 
1888  // AltLeft
1889  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1890  KeyStateChange{VK_LMENU, true, true}, event1});
1891  EXPECT_EQ(tester.key_calls.size(), 2);
1892  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1893  kPhysicalAltLeft, kLogicalAltLeft, "", kSynthesized);
1894  tester.clear_key_calls();
1895  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1896 
1897  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1898  KeyStateChange{VK_LMENU, false, true}, event2});
1899  EXPECT_EQ(tester.key_calls.size(), 2);
1900  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1901  kPhysicalAltLeft, kLogicalAltLeft, "", kSynthesized);
1902  tester.clear_key_calls();
1903  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1904 
1905  // AltRight
1906  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1907  KeyStateChange{VK_RMENU, true, true}, event1});
1908  EXPECT_EQ(tester.key_calls.size(), 2);
1909  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1910  kPhysicalAltRight, kLogicalAltRight, "", kSynthesized);
1911  tester.clear_key_calls();
1912  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1913 
1914  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1915  KeyStateChange{VK_RMENU, false, true}, event2});
1916  EXPECT_EQ(tester.key_calls.size(), 2);
1917  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1918  kPhysicalAltRight, kLogicalAltRight, "", kSynthesized);
1919  tester.clear_key_calls();
1920  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1921 
1922  // MetaLeft
1923  tester.InjectKeyboardChanges(
1924  std::vector<KeyboardChange>{KeyStateChange{VK_LWIN, true, true}, event1});
1925  EXPECT_EQ(tester.key_calls.size(), 2);
1926  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1927  kPhysicalMetaLeft, kLogicalMetaLeft, "", kSynthesized);
1928  tester.clear_key_calls();
1929  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1930 
1931  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1932  KeyStateChange{VK_LWIN, false, true}, event2});
1933  EXPECT_EQ(tester.key_calls.size(), 2);
1934  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1935  kPhysicalMetaLeft, kLogicalMetaLeft, "", kSynthesized);
1936  tester.clear_key_calls();
1937  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1938 
1939  // MetaRight
1940  tester.InjectKeyboardChanges(
1941  std::vector<KeyboardChange>{KeyStateChange{VK_RWIN, true, true}, event1});
1942  EXPECT_EQ(tester.key_calls.size(), 2);
1943  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1944  kPhysicalMetaRight, kLogicalMetaRight, "", kSynthesized);
1945  tester.clear_key_calls();
1946  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1947 
1948  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1949  KeyStateChange{VK_RWIN, false, true}, event2});
1950  EXPECT_EQ(tester.key_calls.size(), 2);
1951  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1952  kPhysicalMetaRight, kLogicalMetaRight, "", kSynthesized);
1953  tester.clear_key_calls();
1954  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1955 
1956  // CapsLock, phase 0 -> 2 -> 0.
1957  // (For phases, see |SynchronizeCriticalToggledStates|.)
1958  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1959  KeyStateChange{VK_CAPITAL, false, true}, event1});
1960  EXPECT_EQ(tester.key_calls.size(), 3);
1961  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1962  kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1963  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1964  kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1965  tester.clear_key_calls();
1966  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1967 
1968  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1969  KeyStateChange{VK_CAPITAL, false, false}, event2});
1970  EXPECT_EQ(tester.key_calls.size(), 3);
1971  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1972  kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1973  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1974  kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1975  tester.clear_key_calls();
1976  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1977 
1978  // ScrollLock, phase 0 -> 1 -> 3
1979  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1980  KeyStateChange{VK_SCROLL, true, true}, event1});
1981  EXPECT_EQ(tester.key_calls.size(), 2);
1982  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1983  kPhysicalScrollLock, kLogicalScrollLock, "",
1984  kSynthesized);
1985  tester.clear_key_calls();
1986  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1987 
1988  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1989  KeyStateChange{VK_SCROLL, true, false}, event2});
1990  EXPECT_EQ(tester.key_calls.size(), 3);
1991  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1992  kPhysicalScrollLock, kLogicalScrollLock, "",
1993  kSynthesized);
1994  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1995  kPhysicalScrollLock, kLogicalScrollLock, "",
1996  kSynthesized);
1997  tester.clear_key_calls();
1998  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1999 
2000  // NumLock, phase 0 -> 3 -> 2
2001  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2002  KeyStateChange{VK_NUMLOCK, true, false}, event1});
2003  // TODO(dkwingsmt): Synthesizing from phase 0 to 3 should yield a full key
2004  // tap and a key down. Fix the algorithm so that the following result becomes
2005  // 4 keycalls with an extra pair of key down and up.
2006  // https://github.com/flutter/flutter/issues/98533
2007  EXPECT_EQ(tester.key_calls.size(), 2);
2008  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2009  kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
2010  tester.clear_key_calls();
2011  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2012 
2013  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2014  KeyStateChange{VK_NUMLOCK, false, true}, event2});
2015  EXPECT_EQ(tester.key_calls.size(), 4);
2016  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2017  kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
2018  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
2019  kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
2020  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeUp,
2021  kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
2022  tester.clear_key_calls();
2023  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2024 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [111/192]

flutter::testing::TEST_F ( KeyboardTest  ,
TextInputSubmit   
)

Definition at line 2236 of file keyboard_unittests.cc.

2236  {
2237  KeyboardTester tester{GetContext()};
2238  tester.Responding(false);
2239 
2240  // US Keyboard layout
2241 
2242  tester.InjectPlatformMessage(
2243  "flutter/textinput", "TextInput.setClient",
2244  R"|([108, {"inputAction": "TextInputAction.none", "viewId": 0}])|");
2245 
2246  // Press Enter
2247  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2248  WmKeyDownInfo{VK_RETURN, kScanCodeEnter, kNotExtended, kWasUp}.Build(
2249  kWmResultZero),
2250  WmCharInfo{'\n', kScanCodeEnter, kNotExtended, kWasUp}.Build(
2251  kWmResultZero)});
2252 
2253  EXPECT_EQ(tester.key_calls.size(), 2);
2254  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2255  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
2256  EXPECT_CALL_IS_TEXT_METHOD_CALL(
2257  tester.key_calls[1],
2258  "{"
2259  R"|("method":"TextInputClient.performAction",)|"
2260  R"|("args":[108,"TextInputAction.none"])|"
2261  "}");
2262  tester.clear_key_calls();
2263  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2264 
2265  // Release Enter
2266  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2267  WmKeyUpInfo{VK_RETURN, kScanCodeEnter, kNotExtended}.Build(
2268  kWmResultZero)});
2269 
2270  EXPECT_EQ(tester.key_calls.size(), 1);
2271  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2272  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
2273  tester.clear_key_calls();
2274  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2275 
2276  // Make sure OnText is not obstructed after pressing Enter.
2277  //
2278  // Regression test for https://github.com/flutter/flutter/issues/97706.
2279 
2280  // Press A
2281  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2282  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2283  kWmResultZero),
2284  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2285  kWmResultZero)});
2286 
2287  EXPECT_EQ(tester.key_calls.size(), 2);
2288  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2289  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2290  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2291  tester.clear_key_calls();
2292 
2293  // Release A
2294  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2295  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2296  kWmResultZero)});
2297 
2298  EXPECT_EQ(tester.key_calls.size(), 1);
2299  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2300  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2301  tester.clear_key_calls();
2302 }
EXPECT_CALL_IS_TEXT_METHOD_CALL
#define EXPECT_CALL_IS_TEXT_METHOD_CALL(_key_call, json_string)
Definition: keyboard_unittests.cc:568

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, EXPECT_CALL_IS_TEXT_METHOD_CALL, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [112/192]

flutter::testing::TEST_F ( KeyboardTest  ,
UpOnlyImeEventsAreCorrectlyHandled   
)

Definition at line 2058 of file keyboard_unittests.cc.

2058  {
2059  KeyboardTester tester{GetContext()};
2060  tester.Responding(true);
2061 
2062  // US Keyboard layout.
2063 
2064  // Press CtrlRight in IME mode.
2065  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2066  KeyStateChange{VK_LSHIFT, true, false},
2067  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
2068  kWmResultZero),
2069  WmKeyDownInfo{VK_PROCESSKEY, kScanCodeDigit2, kNotExtended, kWasUp}.Build(
2070  kWmResultZero),
2071  KeyStateChange{VK_LSHIFT, false, true},
2072  WmKeyUpInfo{VK_PROCESSKEY, kScanCodeShiftLeft, kNotExtended}.Build(
2073  kWmResultZero),
2074  WmKeyUpInfo{'2', kScanCodeDigit2, kNotExtended, kWasUp}.Build(
2075  kWmResultZero)});
2076 
2077  EXPECT_EQ(tester.key_calls.size(), 4);
2078  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2079  kPhysicalShiftLeft, kLogicalShiftLeft, "",
2080  kNotSynthesized);
2081  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown, 0, 0, "",
2082  kNotSynthesized);
2083  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeUp,
2084  kPhysicalShiftLeft, kLogicalShiftLeft, "",
2085  kNotSynthesized);
2086  EXPECT_CALL_IS_EVENT(tester.key_calls[3], kFlutterKeyEventTypeDown, 0, 0, "",
2087  kNotSynthesized);
2088  tester.clear_key_calls();
2089 }

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [113/192]

flutter::testing::TEST_F ( KeyboardTest  ,
VietnameseTelexAddDiacriticWithFastResponse   
)

Definition at line 2304 of file keyboard_unittests.cc.

2304  {
2305  // In this test, the user presses the folloing keys:
2306  //
2307  // Key Current text
2308  // ===========================
2309  // A a
2310  // F à
2311  //
2312  // And the Backspace event is responded immediately.
2313 
2314  KeyboardTester tester{GetContext()};
2315  tester.Responding(false);
2316 
2317  // US Keyboard layout
2318 
2319  // Press A
2320  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2321  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2322  kWmResultZero),
2323  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2324  kWmResultZero)});
2325 
2326  EXPECT_EQ(tester.key_calls.size(), 2);
2327  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2328  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2329  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2330  tester.clear_key_calls();
2331  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2332 
2333  // Release A
2334  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2335  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2336  kWmResultZero)});
2337 
2338  EXPECT_EQ(tester.key_calls.size(), 1);
2339  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2340  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2341  tester.clear_key_calls();
2342  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2343 
2344  // Press F, which is translated to:
2345  //
2346  // Backspace down, char & up, then VK_PACKET('à').
2347  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2348  WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2349  kWmResultZero),
2350  WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2351  kWmResultZero),
2352  WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2353  kWmResultZero),
2354  WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2355  WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2356  WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2357 
2358  EXPECT_EQ(tester.key_calls.size(), 3);
2359  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2360  kPhysicalBackspace, kLogicalBackspace, "",
2361  kNotSynthesized);
2362  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
2363  kPhysicalBackspace, kLogicalBackspace, "",
2364  kNotSynthesized);
2365  EXPECT_CALL_IS_TEXT(tester.key_calls[2], u"à");
2366  tester.clear_key_calls();
2367  // TODO(dkwingsmt): This count should probably be 4. Currently the CHAR 0x8
2368  // message is redispatched due to being part of the KeyDown session, which is
2369  // not handled by the framework, while the 'à' message is not redispatched
2370  // for being a standalone message. We should resolve this inconsistency.
2371  // https://github.com/flutter/flutter/issues/98306
2372  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
2373 
2374  // Release F
2375  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2376  WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2377  /* overwrite_prev_state_0 */ true}
2378  .Build(kWmResultZero)});
2379 
2380  EXPECT_EQ(tester.key_calls.size(), 1);
2381  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2382  kNotSynthesized);
2383  tester.clear_key_calls();
2384  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2385 }

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [114/192]

flutter::testing::TEST_F ( KeyboardTest  ,
VietnameseTelexAddDiacriticWithSlowFalseResponse   
)

Definition at line 2494 of file keyboard_unittests.cc.

2494  {
2495  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), false);
2496 }
flutter::testing::VietnameseTelexAddDiacriticWithSlowResponse
void VietnameseTelexAddDiacriticWithSlowResponse(WindowsTestContext &context, bool backspace_response)
Definition: keyboard_unittests.cc:2387

References VietnameseTelexAddDiacriticWithSlowResponse().

◆ TEST_F() [115/192]

flutter::testing::TEST_F ( KeyboardTest  ,
VietnameseTelexAddDiacriticWithSlowTrueResponse   
)

Definition at line 2498 of file keyboard_unittests.cc.

2498  {
2499  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), true);
2500 }

References VietnameseTelexAddDiacriticWithSlowResponse().

◆ TEST_F() [116/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardHasStrings   
)

Definition at line 240 of file platform_handler_unittests.cc.

240  {
241  UseHeadlessEngine();
242 
243  TestBinaryMessenger messenger;
244  PlatformHandler platform_handler(&messenger, engine(), []() {
245  auto clipboard = std::make_unique<MockScopedClipboard>();
246 
247  EXPECT_CALL(*clipboard.get(), Open)
248  .Times(1)
249  .WillOnce(Return(kErrorSuccess));
250  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
251 
252  return clipboard;
253  });
254 
255  std::string result =
256  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
257 
258  EXPECT_EQ(result, "[{\"value\":true}]");
259 }
kErrorSuccess
static constexpr int kErrorSuccess
Definition: platform_handler.cc:45

References kErrorSuccess.

◆ TEST_F() [117/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardHasStringsIgnoresPermissionErrors   
)

Definition at line 295 of file platform_handler_unittests.cc.

295  {
296  UseHeadlessEngine();
297 
298  TestBinaryMessenger messenger;
299  PlatformHandler platform_handler(&messenger, engine(), []() {
300  auto clipboard = std::make_unique<MockScopedClipboard>();
301 
302  EXPECT_CALL(*clipboard.get(), Open)
303  .Times(1)
304  .WillOnce(Return(kAccessDeniedErrorCode));
305 
306  return clipboard;
307  });
308 
309  std::string result =
310  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
311 
312  EXPECT_EQ(result, "[{\"value\":false}]");
313 }
kAccessDeniedErrorCode
static constexpr int kAccessDeniedErrorCode
Definition: platform_handler.cc:44

References kAccessDeniedErrorCode.

◆ TEST_F() [118/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardHasStringsRejectsUnknownContentType   
)

Definition at line 282 of file platform_handler_unittests.cc.

282  {
283  UseHeadlessEngine();
284 
285  TestBinaryMessenger messenger;
286  PlatformHandler platform_handler(&messenger, engine());
287 
288  std::string result = SimulatePlatformMessage(
289  &messenger, kClipboardHasStringsFakeContentTypeMessage);
290 
291  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
292 }

◆ TEST_F() [119/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardHasStringsReportsErrors   
)

Definition at line 315 of file platform_handler_unittests.cc.

315  {
316  UseHeadlessEngine();
317 
318  TestBinaryMessenger messenger;
319  PlatformHandler platform_handler(&messenger, engine(), []() {
320  auto clipboard = std::make_unique<MockScopedClipboard>();
321 
322  EXPECT_CALL(*clipboard.get(), Open)
323  .Times(1)
324  .WillOnce(Return(kArbitraryErrorCode));
325 
326  return clipboard;
327  });
328 
329  std::string result =
330  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
331 
332  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
333 }

◆ TEST_F() [120/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardHasStringsReturnsFalse   
)

Definition at line 261 of file platform_handler_unittests.cc.

261  {
262  UseHeadlessEngine();
263 
264  TestBinaryMessenger messenger;
265  PlatformHandler platform_handler(&messenger, engine(), []() {
266  auto clipboard = std::make_unique<MockScopedClipboard>();
267 
268  EXPECT_CALL(*clipboard.get(), Open)
269  .Times(1)
270  .WillOnce(Return(kErrorSuccess));
271  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(false));
272 
273  return clipboard;
274  });
275 
276  std::string result =
277  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
278 
279  EXPECT_EQ(result, "[{\"value\":false}]");
280 }

References kErrorSuccess.

◆ TEST_F() [121/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardSetData   
)

Definition at line 335 of file platform_handler_unittests.cc.

335  {
336  UseHeadlessEngine();
337 
338  TestBinaryMessenger messenger;
339  PlatformHandler platform_handler(&messenger, engine(), []() {
340  auto clipboard = std::make_unique<MockScopedClipboard>();
341 
342  EXPECT_CALL(*clipboard.get(), Open)
343  .Times(1)
344  .WillOnce(Return(kErrorSuccess));
345  EXPECT_CALL(*clipboard.get(), SetString)
346  .Times(1)
347  .WillOnce([](std::wstring string) {
348  EXPECT_EQ(string, L"hello");
349  return kErrorSuccess;
350  });
351 
352  return clipboard;
353  });
354 
355  std::string result =
356  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
357 
358  EXPECT_EQ(result, "[null]");
359 }

References kErrorSuccess.

◆ TEST_F() [122/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardSetDataReportsOpenFailure   
)

Definition at line 386 of file platform_handler_unittests.cc.

386  {
387  UseHeadlessEngine();
388 
389  TestBinaryMessenger messenger;
390  PlatformHandler platform_handler(&messenger, engine(), []() {
391  auto clipboard = std::make_unique<MockScopedClipboard>();
392 
393  EXPECT_CALL(*clipboard.get(), Open)
394  .Times(1)
395  .WillOnce(Return(kArbitraryErrorCode));
396 
397  return clipboard;
398  });
399 
400  std::string result =
401  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
402 
403  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
404 }

◆ TEST_F() [123/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardSetDataReportsSetDataFailure   
)

Definition at line 406 of file platform_handler_unittests.cc.

406  {
407  UseHeadlessEngine();
408 
409  TestBinaryMessenger messenger;
410  PlatformHandler platform_handler(&messenger, engine(), []() {
411  auto clipboard = std::make_unique<MockScopedClipboard>();
412 
413  EXPECT_CALL(*clipboard.get(), Open)
414  .Times(1)
415  .WillOnce(Return(kErrorSuccess));
416  EXPECT_CALL(*clipboard.get(), SetString)
417  .Times(1)
418  .WillOnce(Return(kArbitraryErrorCode));
419 
420  return clipboard;
421  });
422 
423  std::string result =
424  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
425 
426  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to set clipboard data\",1]");
427 }

References kErrorSuccess.

◆ TEST_F() [124/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardSetDataTextMustBeString   
)

Definition at line 362 of file platform_handler_unittests.cc.

362  {
363  UseHeadlessEngine();
364 
365  TestBinaryMessenger messenger;
366  PlatformHandler platform_handler(&messenger, engine());
367 
368  std::string result =
369  SimulatePlatformMessage(&messenger, kClipboardSetDataNullTextMessage);
370 
371  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
372 }

◆ TEST_F() [125/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
ClipboardSetDataUnknownType   
)

Definition at line 374 of file platform_handler_unittests.cc.

374  {
375  UseHeadlessEngine();
376 
377  TestBinaryMessenger messenger;
378  PlatformHandler platform_handler(&messenger, engine());
379 
380  std::string result =
381  SimulatePlatformMessage(&messenger, kClipboardSetDataUnknownTypeMessage);
382 
383  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
384 }

◆ TEST_F() [126/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
GetClipboardData   
)

Definition at line 159 of file platform_handler_unittests.cc.

159  {
160  UseHeadlessEngine();
161 
162  TestBinaryMessenger messenger;
163  PlatformHandler platform_handler(&messenger, engine(), []() {
164  auto clipboard = std::make_unique<MockScopedClipboard>();
165 
166  EXPECT_CALL(*clipboard.get(), Open)
167  .Times(1)
168  .WillOnce(Return(kErrorSuccess));
169  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
170  EXPECT_CALL(*clipboard.get(), GetString)
171  .Times(1)
172  .WillOnce(Return(std::wstring(L"Hello world")));
173 
174  return clipboard;
175  });
176 
177  std::string result =
178  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
179 
180  EXPECT_EQ(result, "[{\"text\":\"Hello world\"}]");
181 }

References kErrorSuccess.

◆ TEST_F() [127/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
GetClipboardDataRejectsUnknownContentType   
)

Definition at line 183 of file platform_handler_unittests.cc.

183  {
184  UseHeadlessEngine();
185 
186  TestBinaryMessenger messenger;
187  PlatformHandler platform_handler(&messenger, engine());
188 
189  // Requesting an unknown content type is an error.
190  std::string result = SimulatePlatformMessage(
191  &messenger, kClipboardGetDataFakeContentTypeMessage);
192 
193  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
194 }

◆ TEST_F() [128/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
GetClipboardDataReportsGetDataFailure   
)

Definition at line 216 of file platform_handler_unittests.cc.

216  {
217  UseHeadlessEngine();
218 
219  TestBinaryMessenger messenger;
220  PlatformHandler platform_handler(&messenger, engine(), []() {
221  auto clipboard = std::make_unique<MockScopedClipboard>();
222 
223  EXPECT_CALL(*clipboard.get(), Open)
224  .Times(1)
225  .WillOnce(Return(kErrorSuccess));
226  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
227  EXPECT_CALL(*clipboard.get(), GetString)
228  .Times(1)
229  .WillOnce(Return(kArbitraryErrorCode));
230 
231  return clipboard;
232  });
233 
234  std::string result =
235  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
236 
237  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to get clipboard data\",1]");
238 }

References kErrorSuccess.

◆ TEST_F() [129/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
GetClipboardDataReportsOpenFailure   
)

Definition at line 196 of file platform_handler_unittests.cc.

196  {
197  UseHeadlessEngine();
198 
199  TestBinaryMessenger messenger;
200  PlatformHandler platform_handler(&messenger, engine(), []() {
201  auto clipboard = std::make_unique<MockScopedClipboard>();
202 
203  EXPECT_CALL(*clipboard.get(), Open)
204  .Times(1)
205  .WillOnce(Return(kArbitraryErrorCode));
206 
207  return clipboard;
208  });
209 
210  std::string result =
211  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
212 
213  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
214 }

◆ TEST_F() [130/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
PlaySystemSound   
)

Definition at line 429 of file platform_handler_unittests.cc.

429  {
430  UseHeadlessEngine();
431 
432  TestBinaryMessenger messenger;
433  MockPlatformHandler platform_handler(&messenger, engine());
434 
435  EXPECT_CALL(platform_handler, SystemSoundPlay("SystemSoundType.alert", _))
436  .WillOnce([](const std::string& sound,
437  std::unique_ptr<MethodResult<rapidjson::Document>> result) {
438  result->Success();
439  });
440 
441  std::string result =
442  SimulatePlatformMessage(&messenger, kSystemSoundTypeAlertMessage);
443 
444  EXPECT_EQ(result, "[null]");
445 }

◆ TEST_F() [131/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
SystemExitApplicationCancelableCancel   
)

Definition at line 469 of file platform_handler_unittests.cc.

469  {
470  UseHeadlessEngine();
471  bool called_cancel = false;
472 
473  TestBinaryMessenger messenger(
474  [&called_cancel](const std::string& channel, const uint8_t* message,
475  size_t size, BinaryReply reply) {
476  reply(reinterpret_cast<const uint8_t*>(kExitResponseCancelMessage),
477  sizeof(kExitResponseCancelMessage));
478  called_cancel = true;
479  });
480  MockPlatformHandler platform_handler(&messenger, engine());
481 
482  EXPECT_CALL(platform_handler, QuitApplication).Times(0);
483 
484  std::string result = SimulatePlatformMessage(
485  &messenger, kSystemExitApplicationCancelableMessage);
486  EXPECT_EQ(result, "[{\"response\":\"cancel\"}]");
487  EXPECT_TRUE(called_cancel);
488 }

References message.

◆ TEST_F() [132/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
SystemExitApplicationCancelableExit   
)

Definition at line 490 of file platform_handler_unittests.cc.

490  {
491  UseHeadlessEngine();
492  bool called_cancel = false;
493  UINT exit_code = 0;
494 
495  TestBinaryMessenger messenger(
496  [&called_cancel](const std::string& channel, const uint8_t* message,
497  size_t size, BinaryReply reply) {
498  reply(reinterpret_cast<const uint8_t*>(kExitResponseExitMessage),
499  sizeof(kExitResponseExitMessage));
500  called_cancel = true;
501  });
502  MockPlatformHandler platform_handler(&messenger, engine());
503 
504  ON_CALL(platform_handler, QuitApplication)
505  .WillByDefault([&exit_code](std::optional<HWND> hwnd,
506  std::optional<WPARAM> wparam,
507  std::optional<LPARAM> lparam,
508  UINT ec) { exit_code = ec; });
509  EXPECT_CALL(platform_handler, QuitApplication).Times(1);
510 
511  std::string result = SimulatePlatformMessage(
512  &messenger, kSystemExitApplicationCancelableMessage);
513  EXPECT_EQ(result, "[{\"response\":\"cancel\"}]");
514  EXPECT_TRUE(called_cancel);
515  EXPECT_EQ(exit_code, 2);
516 }

References message.

◆ TEST_F() [133/192]

flutter::testing::TEST_F ( PlatformHandlerTest  ,
SystemExitApplicationRequired   
)

Definition at line 447 of file platform_handler_unittests.cc.

447  {
448  UseHeadlessEngine();
449  UINT exit_code = 0;
450 
451  TestBinaryMessenger messenger([](const std::string& channel,
452  const uint8_t* message, size_t size,
453  BinaryReply reply) {});
454  MockPlatformHandler platform_handler(&messenger, engine());
455 
456  ON_CALL(platform_handler, QuitApplication)
457  .WillByDefault([&exit_code](std::optional<HWND> hwnd,
458  std::optional<WPARAM> wparam,
459  std::optional<LPARAM> lparam,
460  UINT ec) { exit_code = ec; });
461  EXPECT_CALL(platform_handler, QuitApplication).Times(1);
462 
463  std::string result = SimulatePlatformMessage(
464  &messenger, kSystemExitApplicationRequiredMessage);
465  EXPECT_EQ(result, "[{\"response\":\"exit\"}]");
466  EXPECT_EQ(exit_code, 1);
467 }

References message.

◆ TEST_F() [134/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
ClearClientRequiresView   
)

Definition at line 244 of file text_input_plugin_unittest.cc.

244  {
245  UseHeadlessEngine();
246 
247  TestBinaryMessenger messenger([](const std::string& channel,
248  const uint8_t* message, size_t message_size,
249  BinaryReply reply) {});
250 
251  std::string reply;
252  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
253  size_t reply_size) {
254  reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
255  };
256 
257  TextInputPlugin handler(&messenger, engine());
258 
259  auto& codec = JsonMethodCodec::GetInstance();
260  auto message = codec.EncodeMethodCall({"TextInput.clearClient", nullptr});
261  messenger.SimulateEngineMessage(kChannelName, message->data(),
262  message->size(), reply_handler);
263 
264  EXPECT_EQ(
265  reply,
266  "[\"Internal Consistency Error\",\"Text input is not available because "
267  "view with view_id=0 cannot be found\",null]");
268 }
kChannelName
static constexpr char kChannelName[]
Definition: cursor_handler.cc:12

References flutter::JsonMethodCodec::GetInstance(), kChannelName, and message.

◆ TEST_F() [135/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
ClearClientResetsComposing   
)

Definition at line 223 of file text_input_plugin_unittest.cc.

223  {
224  UseEngineWithView();
225 
226  TestBinaryMessenger messenger([](const std::string& channel,
227  const uint8_t* message, size_t message_size,
228  BinaryReply reply) {});
229  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
230 
231  TextInputPlugin handler(&messenger, engine());
232  TextInputPluginModifier modifier(&handler);
233  modifier.SetViewId(456);
234 
235  EXPECT_CALL(*view(), OnResetImeComposing());
236 
237  auto& codec = JsonMethodCodec::GetInstance();
238  auto message = codec.EncodeMethodCall({"TextInput.clearClient", nullptr});
239  messenger.SimulateEngineMessage(kChannelName, message->data(),
240  message->size(), reply_handler);
241 }

References flutter::JsonMethodCodec::GetInstance(), kChannelName, message, and flutter::TextInputPluginModifier::SetViewId().

◆ TEST_F() [136/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
CompositionCursorPos   
)

Definition at line 558 of file text_input_plugin_unittest.cc.

558  {
559  UseEngineWithView();
560 
561  int selection_base = -1;
562  TestBinaryMessenger messenger([&](const std::string& channel,
563  const uint8_t* message, size_t size,
564  BinaryReply reply) {
565  auto method = JsonMethodCodec::GetInstance().DecodeMethodCall(
566  std::vector<uint8_t>(message, message + size));
567  if (method->method_name() == kUpdateEditingStateMethod) {
568  const auto& args = *method->arguments();
569  const auto& editing_state = args[1];
570  auto base = editing_state.FindMember(kSelectionBaseKey);
571  auto extent = editing_state.FindMember(kSelectionExtentKey);
572  ASSERT_NE(base, editing_state.MemberEnd());
573  ASSERT_TRUE(base->value.IsInt());
574  ASSERT_NE(extent, editing_state.MemberEnd());
575  ASSERT_TRUE(extent->value.IsInt());
576  selection_base = base->value.GetInt();
577  EXPECT_EQ(extent->value.GetInt(), selection_base);
578  }
579  });
580 
581  TextInputPlugin plugin(&messenger, engine());
582 
583  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
584  auto& allocator = args->GetAllocator();
585  args->PushBack(123, allocator); // client_id
586  rapidjson::Value client_config(rapidjson::kObjectType);
587  client_config.AddMember(kViewId, 456, allocator);
588  args->PushBack(client_config, allocator);
589  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
590  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
591  EXPECT_TRUE(messenger.SimulateEngineMessage(
592  kChannelName, encoded->data(), encoded->size(),
593  [](const uint8_t* reply, size_t reply_size) {}));
594 
595  plugin.ComposeBeginHook();
596  EXPECT_EQ(selection_base, 0);
597  plugin.ComposeChangeHook(u"abc", 3);
598  EXPECT_EQ(selection_base, 3);
599 
600  plugin.ComposeCommitHook();
601  plugin.ComposeEndHook();
602  EXPECT_EQ(selection_base, 3);
603 
604  plugin.ComposeBeginHook();
605  plugin.ComposeChangeHook(u"1", 1);
606  EXPECT_EQ(selection_base, 4);
607 
608  plugin.ComposeChangeHook(u"12", 2);
609  EXPECT_EQ(selection_base, 5);
610 
611  plugin.ComposeChangeHook(u"12", 1);
612  EXPECT_EQ(selection_base, 4);
613 
614  plugin.ComposeChangeHook(u"12", 2);
615  EXPECT_EQ(selection_base, 5);
616 }
kSelectionExtentKey
static constexpr char kSelectionExtentKey[]
Definition: text_input_plugin.cc:49
kSetClientMethod
static constexpr char kSetClientMethod[]
Definition: text_input_plugin.cc:19
kUpdateEditingStateMethod
static constexpr char kUpdateEditingStateMethod[]
Definition: text_input_plugin.cc:28
kViewId
static constexpr char kViewId[]
Definition: text_input_plugin.cc:41
kSelectionBaseKey
static constexpr char kSelectionBaseKey[]
Definition: text_input_plugin.cc:48

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), flutter::JsonMethodCodec::GetInstance(), kChannelName, kSelectionBaseKey, kSelectionExtentKey, kSetClientMethod, kUpdateEditingStateMethod, kViewId, and message.

◆ TEST_F() [137/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
SetAndUseMultipleClients   
)

Definition at line 728 of file text_input_plugin_unittest.cc.

728  {
729  UseEngineWithView(); // Creates the default view
730  AddViewWithId(789); // Creates the next view
731 
732  bool sent_message = false;
733  TestBinaryMessenger messenger(
734  [&sent_message](const std::string& channel, const uint8_t* message,
735  size_t message_size,
736  BinaryReply reply) { sent_message = true; });
737 
738  TextInputPlugin handler(&messenger, engine());
739 
740  auto const set_client_and_send_message = [&](int client_id, int view_id) {
741  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
742  auto& allocator = args->GetAllocator();
743  args->PushBack(client_id, allocator); // client_id
744 
745  rapidjson::Value client_config(rapidjson::kObjectType);
746  client_config.AddMember(kViewId, view_id, allocator); // view_id
747 
748  args->PushBack(client_config, allocator);
749  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
750  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
751 
752  std::string reply;
753  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
754  size_t reply_size) {
755  reply =
756  std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
757  };
758 
759  EXPECT_TRUE(messenger.SimulateEngineMessage(
760  kChannelName, encoded->data(), encoded->size(), reply_handler));
761 
762  sent_message = false;
763  handler.ComposeBeginHook();
764  EXPECT_TRUE(sent_message);
765  sent_message = false;
766  handler.ComposeChangeHook(u"4", 1);
767  EXPECT_TRUE(sent_message);
768  sent_message = false;
769  handler.ComposeCommitHook();
770  EXPECT_FALSE(sent_message);
771  sent_message = false;
772  handler.ComposeEndHook();
773  EXPECT_TRUE(sent_message);
774  };
775 
776  set_client_and_send_message(123, 456); // Set and send for the first view
777  set_client_and_send_message(123, 789); // Set and send for the next view
778 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::JsonMethodCodec::GetInstance(), kChannelName, kSetClientMethod, kViewId, and message.

◆ TEST_F() [138/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
SetClientRequiresViewId   
)

Definition at line 434 of file text_input_plugin_unittest.cc.

434  {
435  UseEngineWithView();
436 
437  TestBinaryMessenger messenger([](const std::string& channel,
438  const uint8_t* message, size_t message_size,
439  BinaryReply reply) {});
440 
441  TextInputPlugin handler(&messenger, engine());
442 
443  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
444  auto& allocator = args->GetAllocator();
445  args->PushBack(123, allocator); // client_id
446 
447  rapidjson::Value client_config(rapidjson::kObjectType);
448 
449  args->PushBack(client_config, allocator);
450  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
451  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
452 
453  std::string reply;
454  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
455  size_t reply_size) {
456  reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
457  };
458 
459  EXPECT_TRUE(messenger.SimulateEngineMessage(kChannelName, encoded->data(),
460  encoded->size(), reply_handler));
461  EXPECT_EQ(
462  reply,
463  "[\"Bad Arguments\",\"Could not set client, view ID is null.\",null]");
464 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::JsonMethodCodec::GetInstance(), kChannelName, kSetClientMethod, and message.

◆ TEST_F() [139/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
SetClientRequiresViewIdToBeInteger   
)

Definition at line 466 of file text_input_plugin_unittest.cc.

466  {
467  UseEngineWithView();
468 
469  TestBinaryMessenger messenger([](const std::string& channel,
470  const uint8_t* message, size_t message_size,
471  BinaryReply reply) {});
472 
473  TextInputPlugin handler(&messenger, engine());
474 
475  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
476  auto& allocator = args->GetAllocator();
477  args->PushBack(123, allocator); // client_id
478 
479  rapidjson::Value client_config(rapidjson::kObjectType);
480  client_config.AddMember(kViewId, "Not an integer", allocator); // view_id
481 
482  args->PushBack(client_config, allocator);
483  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
484  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
485 
486  std::string reply;
487  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
488  size_t reply_size) {
489  reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
490  };
491 
492  EXPECT_TRUE(messenger.SimulateEngineMessage(kChannelName, encoded->data(),
493  encoded->size(), reply_handler));
494  EXPECT_EQ(
495  reply,
496  "[\"Bad Arguments\",\"Could not set client, view ID is null.\",null]");
497 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::JsonMethodCodec::GetInstance(), kChannelName, kSetClientMethod, kViewId, and message.

◆ TEST_F() [140/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
SetMarkedTextRectRequiresView   
)

Definition at line 691 of file text_input_plugin_unittest.cc.

691  {
692  UseHeadlessEngine();
693 
694  TestBinaryMessenger messenger([](const std::string& channel,
695  const uint8_t* message, size_t message_size,
696  BinaryReply reply) {});
697 
698  std::string reply;
699  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
700  size_t reply_size) {
701  reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
702  };
703 
704  TextInputPlugin handler(&messenger, engine());
705 
706  auto& codec = JsonMethodCodec::GetInstance();
707 
708  auto arguments =
709  std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
710  auto& allocator = arguments->GetAllocator();
711 
712  arguments->AddMember("x", 0, allocator);
713  arguments->AddMember("y", 0, allocator);
714  arguments->AddMember("width", 0, allocator);
715  arguments->AddMember("height", 0, allocator);
716 
717  auto message = codec.EncodeMethodCall(
718  {"TextInput.setMarkedTextRect", std::move(arguments)});
719  messenger.SimulateEngineMessage(kChannelName, message->data(),
720  message->size(), reply_handler);
721 
722  EXPECT_EQ(
723  reply,
724  "[\"Internal Consistency Error\",\"Text input is not available because "
725  "view with view_id=0 cannot be found\",null]");
726 }

References flutter::JsonMethodCodec::GetInstance(), kChannelName, and message.

◆ TEST_F() [141/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
TextEditingWorksWithDeltaModel   
)

Definition at line 499 of file text_input_plugin_unittest.cc.

499  {
500  UseEngineWithView();
501 
502  auto handled_message = CreateResponse(true);
503  auto unhandled_message = CreateResponse(false);
504  int received_scancode = 0;
505 
506  TestBinaryMessenger messenger(
507  [&received_scancode, &handled_message, &unhandled_message](
508  const std::string& channel, const uint8_t* message,
509  size_t message_size, BinaryReply reply) {});
510 
511  int redispatch_scancode = 0;
512  TextInputPlugin handler(&messenger, engine());
513 
514  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
515  auto& allocator = args->GetAllocator();
516  args->PushBack(123, allocator); // client_id
517 
518  rapidjson::Value client_config(rapidjson::kObjectType);
519  client_config.AddMember(kEnableDeltaModel, true, allocator);
520  client_config.AddMember(kViewId, 456, allocator);
521 
522  args->PushBack(client_config, allocator);
523  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
524  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
525 
526  EXPECT_TRUE(messenger.SimulateEngineMessage(
527  kChannelName, encoded->data(), encoded->size(),
528  [](const uint8_t* reply, size_t reply_size) {}));
529 
530  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
531  handler.ComposeBeginHook();
532  std::u16string text;
533  text.push_back('\n');
534  handler.ComposeChangeHook(text, 1);
535  handler.ComposeEndHook();
536 
537  handler.KeyboardHook(0x4E, 100, WM_KEYDOWN, 'n', false, false);
538  handler.ComposeBeginHook();
539  std::u16string textN;
540  text.push_back('n');
541  handler.ComposeChangeHook(textN, 1);
542  handler.KeyboardHook(0x49, 100, WM_KEYDOWN, 'i', false, false);
543  std::u16string textNi;
544  text.push_back('n');
545  text.push_back('i');
546  handler.ComposeChangeHook(textNi, 2);
547  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
548  std::u16string textChineseCharacter;
549  text.push_back(u'\u4F60');
550  handler.ComposeChangeHook(textChineseCharacter, 1);
551  handler.ComposeCommitHook();
552  handler.ComposeEndHook();
553 
554  // Passes if it did not crash
555 }
text
std::u16string text
Definition: keyboard_unittests.cc:332
kEnableDeltaModel
static constexpr char kEnableDeltaModel[]
Definition: text_input_plugin.cc:39

References flutter::TextInputPlugin::ComposeBeginHook(), flutter::TextInputPlugin::ComposeChangeHook(), flutter::TextInputPlugin::ComposeCommitHook(), flutter::TextInputPlugin::ComposeEndHook(), flutter::MethodCodec< T >::EncodeMethodCall(), flutter::JsonMethodCodec::GetInstance(), kChannelName, kEnableDeltaModel, flutter::TextInputPlugin::KeyboardHook(), kSetClientMethod, kViewId, message, and text.

◆ TEST_F() [142/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
TextMethodsWorksWithEmptyModel   
)

Definition at line 198 of file text_input_plugin_unittest.cc.

198  {
199  UseEngineWithView();
200 
201  auto handled_message = CreateResponse(true);
202  auto unhandled_message = CreateResponse(false);
203  int received_scancode = 0;
204 
205  TestBinaryMessenger messenger(
206  [&received_scancode, &handled_message, &unhandled_message](
207  const std::string& channel, const uint8_t* message,
208  size_t message_size, BinaryReply reply) {});
209 
210  int redispatch_scancode = 0;
211  TextInputPlugin handler(&messenger, engine());
212 
213  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
214  handler.ComposeBeginHook();
215  std::u16string text;
216  text.push_back('\n');
217  handler.ComposeChangeHook(text, 1);
218  handler.ComposeEndHook();
219 
220  // Passes if it did not crash
221 }

References flutter::TextInputPlugin::ComposeBeginHook(), flutter::TextInputPlugin::ComposeChangeHook(), flutter::TextInputPlugin::ComposeEndHook(), flutter::TextInputPlugin::KeyboardHook(), message, and text.

◆ TEST_F() [143/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
TransformCursorRect   
)

Definition at line 618 of file text_input_plugin_unittest.cc.

618  {
619  UseEngineWithView();
620 
621  // A position of `EditableText`.
622  double view_x = 100;
623  double view_y = 200;
624 
625  // A position and size of marked text, in `EditableText` local coordinates.
626  double ime_x = 3;
627  double ime_y = 4;
628  double ime_width = 50;
629  double ime_height = 60;
630 
631  // Transformation matrix.
632  std::array<std::array<double, 4>, 4> editabletext_transform = {
633  1.0, 0.0, 0.0, view_x, //
634  0.0, 1.0, 0.0, view_y, //
635  0.0, 0.0, 0.0, 0.0, //
636  0.0, 0.0, 0.0, 1.0};
637 
638  TestBinaryMessenger messenger([](const std::string& channel,
639  const uint8_t* message, size_t message_size,
640  BinaryReply reply) {});
641  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
642 
643  TextInputPlugin handler(&messenger, engine());
644  TextInputPluginModifier modifier(&handler);
645  modifier.SetViewId(456);
646 
647  auto& codec = JsonMethodCodec::GetInstance();
648 
649  EXPECT_CALL(*view(), OnCursorRectUpdated(Rect{{view_x, view_y}, {0, 0}}));
650 
651  {
652  auto arguments =
653  std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
654  auto& allocator = arguments->GetAllocator();
655 
656  rapidjson::Value transoform(rapidjson::kArrayType);
657  for (int i = 0; i < 4 * 4; i++) {
658  // Pack 2-dimensional array by column-major order.
659  transoform.PushBack(editabletext_transform[i % 4][i / 4], allocator);
660  }
661 
662  arguments->AddMember("transform", transoform, allocator);
663 
664  auto message = codec.EncodeMethodCall(
665  {"TextInput.setEditableSizeAndTransform", std::move(arguments)});
666  messenger.SimulateEngineMessage(kChannelName, message->data(),
667  message->size(), reply_handler);
668  }
669 
670  EXPECT_CALL(*view(),
671  OnCursorRectUpdated(Rect{{view_x + ime_x, view_y + ime_y},
672  {ime_width, ime_height}}));
673 
674  {
675  auto arguments =
676  std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
677  auto& allocator = arguments->GetAllocator();
678 
679  arguments->AddMember("x", ime_x, allocator);
680  arguments->AddMember("y", ime_y, allocator);
681  arguments->AddMember("width", ime_width, allocator);
682  arguments->AddMember("height", ime_height, allocator);
683 
684  auto message = codec.EncodeMethodCall(
685  {"TextInput.setMarkedTextRect", std::move(arguments)});
686  messenger.SimulateEngineMessage(kChannelName, message->data(),
687  message->size(), reply_handler);
688  }
689 }

References flutter::JsonMethodCodec::GetInstance(), kChannelName, message, and flutter::TextInputPluginModifier::SetViewId().

◆ TEST_F() [144/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
VerifyComposingSendStateUpdate   
)

Definition at line 272 of file text_input_plugin_unittest.cc.

272  {
273  UseEngineWithView();
274 
275  bool sent_message = false;
276  TestBinaryMessenger messenger(
277  [&sent_message](const std::string& channel, const uint8_t* message,
278  size_t message_size,
279  BinaryReply reply) { sent_message = true; });
280  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
281 
282  TextInputPlugin handler(&messenger, engine());
283 
284  auto& codec = JsonMethodCodec::GetInstance();
285 
286  // Call TextInput.setClient to initialize the TextInputModel.
287  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
288  auto& allocator = arguments->GetAllocator();
289  arguments->PushBack(kDefaultClientId, allocator);
290  rapidjson::Value config(rapidjson::kObjectType);
291  config.AddMember("inputAction", "done", allocator);
292  config.AddMember("inputType", "text", allocator);
293  config.AddMember(kEnableDeltaModel, false, allocator);
294  config.AddMember(kViewId, 456, allocator);
295  arguments->PushBack(config, allocator);
296  auto message =
297  codec.EncodeMethodCall({"TextInput.setClient", std::move(arguments)});
298  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
299  message->size(), reply_handler);
300 
301  // ComposeBeginHook should send state update.
302  sent_message = false;
303  handler.ComposeBeginHook();
304  EXPECT_TRUE(sent_message);
305 
306  // ComposeChangeHook should send state update.
307  sent_message = false;
308  handler.ComposeChangeHook(u"4", 1);
309  EXPECT_TRUE(sent_message);
310 
311  // ComposeCommitHook should NOT send state update.
312  //
313  // Commit messages are always immediately followed by a change message or an
314  // end message, both of which will send an update. Sending intermediate state
315  // with a collapsed composing region will trigger the framework to assume
316  // composing has ended, which is not the case until a WM_IME_ENDCOMPOSING
317  // event is received in the main event loop, which will trigger a call to
318  // ComposeEndHook.
319  sent_message = false;
320  handler.ComposeCommitHook();
321  EXPECT_FALSE(sent_message);
322 
323  // ComposeEndHook should send state update.
324  sent_message = false;
325  handler.ComposeEndHook();
326  EXPECT_TRUE(sent_message);
327 }

References flutter::TextInputPlugin::ComposeBeginHook(), flutter::TextInputPlugin::ComposeChangeHook(), flutter::TextInputPlugin::ComposeCommitHook(), flutter::TextInputPlugin::ComposeEndHook(), flutter::JsonMethodCodec::GetInstance(), kEnableDeltaModel, kViewId, and message.

◆ TEST_F() [145/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
VerifyInputActionNewlineInsertNewLine   
)

Definition at line 329 of file text_input_plugin_unittest.cc.

329  {
330  UseEngineWithView();
331 
332  // Store messages as std::string for convenience.
333  std::vector<std::string> messages;
334 
335  TestBinaryMessenger messenger(
336  [&messages](const std::string& channel, const uint8_t* message,
337  size_t message_size, BinaryReply reply) {
338  std::string last_message(reinterpret_cast<const char*>(message),
339  message_size);
340  messages.push_back(last_message);
341  });
342  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
343 
344  TextInputPlugin handler(&messenger, engine());
345 
346  auto& codec = JsonMethodCodec::GetInstance();
347 
348  // Call TextInput.setClient to initialize the TextInputModel.
349  auto set_client_arguments =
350  EncodedClientConfig("TextInputType.multiline", "TextInputAction.newline");
351  auto message = codec.EncodeMethodCall(
352  {"TextInput.setClient", std::move(set_client_arguments)});
353  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
354  message->size(), reply_handler);
355 
356  // Simulate a key down event for '\n'.
357  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
358 
359  // Two messages are expected, the first is TextInput.updateEditingState and
360  // the second is TextInputClient.performAction.
361  EXPECT_EQ(messages.size(), 2);
362 
363  // Editing state should have been updated.
364  auto encoded_arguments = EncodedEditingState("\n", TextRange(1));
365  auto update_state_message = codec.EncodeMethodCall(
366  {kUpdateEditingStateMethod, std::move(encoded_arguments)});
367 
368  EXPECT_TRUE(std::equal(update_state_message->begin(),
369  update_state_message->end(),
370  messages.front().begin()));
371 
372  // TextInputClient.performAction should have been called.
373  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
374  auto& allocator = arguments->GetAllocator();
375  arguments->PushBack(kDefaultClientId, allocator);
376  arguments->PushBack(
377  rapidjson::Value("TextInputAction.newline", allocator).Move(), allocator);
378  auto invoke_action_message = codec.EncodeMethodCall(
379  {"TextInputClient.performAction", std::move(arguments)});
380 
381  EXPECT_TRUE(std::equal(invoke_action_message->begin(),
382  invoke_action_message->end(),
383  messages.back().begin()));
384 }

References flutter::JsonMethodCodec::GetInstance(), flutter::TextInputPlugin::KeyboardHook(), kUpdateEditingStateMethod, and message.

◆ TEST_F() [146/192]

flutter::testing::TEST_F ( TextInputPluginTest  ,
VerifyInputActionSendDoesNotInsertNewLine   
)

Definition at line 387 of file text_input_plugin_unittest.cc.

387  {
388  UseEngineWithView();
389 
390  std::vector<std::vector<uint8_t>> messages;
391 
392  TestBinaryMessenger messenger(
393  [&messages](const std::string& channel, const uint8_t* message,
394  size_t message_size, BinaryReply reply) {
395  int length = static_cast<int>(message_size);
396  std::vector<uint8_t> last_message(length);
397  memcpy(&last_message[0], &message[0], length * sizeof(uint8_t));
398  messages.push_back(last_message);
399  });
400  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
401 
402  TextInputPlugin handler(&messenger, engine());
403 
404  auto& codec = JsonMethodCodec::GetInstance();
405 
406  // Call TextInput.setClient to initialize the TextInputModel.
407  auto set_client_arguments =
408  EncodedClientConfig("TextInputType.multiline", "TextInputAction.send");
409  auto message = codec.EncodeMethodCall(
410  {"TextInput.setClient", std::move(set_client_arguments)});
411  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
412  message->size(), reply_handler);
413 
414  // Simulate a key down event for '\n'.
415  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
416 
417  // Only a call to TextInputClient.performAction is expected.
418  EXPECT_EQ(messages.size(), 1);
419 
420  // TextInputClient.performAction should have been called.
421  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
422  auto& allocator = arguments->GetAllocator();
423  arguments->PushBack(kDefaultClientId, allocator);
424  arguments->PushBack(
425  rapidjson::Value("TextInputAction.send", allocator).Move(), allocator);
426  auto invoke_action_message = codec.EncodeMethodCall(
427  {"TextInputClient.performAction", std::move(arguments)});
428 
429  EXPECT_TRUE(std::equal(invoke_action_message->begin(),
430  invoke_action_message->end(),
431  messages.front().begin()));
432 }

References flutter::JsonMethodCodec::GetInstance(), flutter::TextInputPlugin::KeyboardHook(), and message.

◆ TEST_F() [147/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CanConstrainByMaximumSize   
)

Definition at line 175 of file window_manager_unittests.cc.

175  {
176  IsolateScope isolate_scope(isolate());
177 
178  const int64_t view_id =
179  InternalFlutterWindows_WindowManager_CreateRegularWindow(
180  engine_id(), regular_creation_request());
181  const HWND window_handle =
182  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
183  view_id);
184  WindowConstraints constraints{.has_view_constraints = true,
185  .view_min_width = 0,
186  .view_min_height = 0,
187  .view_max_width = 500,
188  .view_max_height = 500};
189  InternalFlutterWindows_WindowManager_SetWindowConstraints(window_handle,
190  &constraints);
191 
192  ActualWindowSize actual_size =
193  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
194  EXPECT_EQ(actual_size.width, 500);
195  EXPECT_EQ(actual_size.height, 500);
196 }
InternalFlutterWindows_WindowManager_SetWindowConstraints
void InternalFlutterWindows_WindowManager_SetWindowConstraints(HWND hwnd, const flutter::WindowConstraints *constraints)
Definition: window_manager.cc:213
InternalFlutterWindows_WindowManager_CreateRegularWindow
FlutterViewId InternalFlutterWindows_WindowManager_CreateRegularWindow(int64_t engine_id, const flutter::RegularWindowCreationRequest *request)
Definition: window_manager.cc:140
InternalFlutterWindows_WindowManager_GetWindowContentSize
flutter::ActualWindowSize InternalFlutterWindows_WindowManager_GetWindowContentSize(HWND hwnd)
Definition: window_manager.cc:180
InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle
HWND InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(int64_t engine_id, FlutterViewId view_id)
Definition: window_manager.cc:166

References flutter::WindowConstraints::has_view_constraints, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetWindowConstraints(), and flutter::ActualWindowSize::width.

◆ TEST_F() [148/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CanConstrainByMinimiumSize   
)

Definition at line 152 of file window_manager_unittests.cc.

152  {
153  IsolateScope isolate_scope(isolate());
154 
155  const int64_t view_id =
156  InternalFlutterWindows_WindowManager_CreateRegularWindow(
157  engine_id(), regular_creation_request());
158  const HWND window_handle =
159  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
160  view_id);
161  WindowConstraints constraints{.has_view_constraints = true,
162  .view_min_width = 900,
163  .view_min_height = 700,
164  .view_max_width = 10000,
165  .view_max_height = 10000};
166  InternalFlutterWindows_WindowManager_SetWindowConstraints(window_handle,
167  &constraints);
168 
169  ActualWindowSize actual_size =
170  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
171  EXPECT_EQ(actual_size.width, 900);
172  EXPECT_EQ(actual_size.height, 700);
173 }

References flutter::WindowConstraints::has_view_constraints, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetWindowConstraints(), and flutter::ActualWindowSize::width.

◆ TEST_F() [149/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CanFullscreenWindow   
)

Definition at line 198 of file window_manager_unittests.cc.

198  {
199  IsolateScope isolate_scope(isolate());
200 
201  const int64_t view_id =
202  InternalFlutterWindows_WindowManager_CreateRegularWindow(
203  engine_id(), regular_creation_request());
204  const HWND window_handle =
205  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
206  view_id);
207 
208  FullscreenRequest request{.fullscreen = true, .has_display_id = false};
209  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
210 
211  int screen_width = GetSystemMetrics(SM_CXSCREEN);
212  int screen_height = GetSystemMetrics(SM_CYSCREEN);
213  ActualWindowSize actual_size =
214  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
215  EXPECT_EQ(actual_size.width, screen_width);
216  EXPECT_EQ(actual_size.height, screen_height);
217  EXPECT_TRUE(
218  InternalFlutterWindows_WindowManager_GetFullscreen(window_handle));
219 }
InternalFlutterWindows_WindowManager_GetFullscreen
bool InternalFlutterWindows_WindowManager_GetFullscreen(HWND hwnd)
Definition: window_manager.cc:235
InternalFlutterWindows_WindowManager_SetFullscreen
void InternalFlutterWindows_WindowManager_SetFullscreen(HWND hwnd, const flutter::FullscreenRequest *request)
Definition: window_manager.cc:222

References flutter::FullscreenRequest::fullscreen, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetFullscreen(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetFullscreen(), and flutter::ActualWindowSize::width.

◆ TEST_F() [150/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CanSetWindowConstraintsWhileFullscreen   
)

Definition at line 276 of file window_manager_unittests.cc.

276  {
277  IsolateScope isolate_scope(isolate());
278 
279  const int64_t view_id =
280  InternalFlutterWindows_WindowManager_CreateRegularWindow(
281  engine_id(), regular_creation_request());
282  const HWND window_handle =
283  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
284  view_id);
285 
286  FullscreenRequest request{.fullscreen = true, .has_display_id = false};
287  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
288 
289  WindowConstraints constraints{.has_view_constraints = true,
290  .view_min_width = 0,
291  .view_min_height = 0,
292  .view_max_width = 500,
293  .view_max_height = 500};
294  InternalFlutterWindows_WindowManager_SetWindowConstraints(window_handle,
295  &constraints);
296 
297  request.fullscreen = false;
298  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
299 
300  ActualWindowSize actual_size =
301  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
302  EXPECT_EQ(actual_size.width, 500);
303  EXPECT_EQ(actual_size.height, 500);
304 }

References flutter::FullscreenRequest::fullscreen, flutter::WindowConstraints::has_view_constraints, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetFullscreen(), InternalFlutterWindows_WindowManager_SetWindowConstraints(), and flutter::ActualWindowSize::width.

◆ TEST_F() [151/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CanSetWindowSizeWhileFullscreen   
)

Definition at line 245 of file window_manager_unittests.cc.

245  {
246  IsolateScope isolate_scope(isolate());
247 
248  const int64_t view_id =
249  InternalFlutterWindows_WindowManager_CreateRegularWindow(
250  engine_id(), regular_creation_request());
251  const HWND window_handle =
252  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
253  view_id);
254 
255  FullscreenRequest request{.fullscreen = true, .has_display_id = false};
256  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
257 
258  WindowSizeRequest requestedSize{
259 
260  .has_preferred_view_size = true,
261  .preferred_view_width = 500,
262  .preferred_view_height = 500,
263  };
264  InternalFlutterWindows_WindowManager_SetWindowSize(window_handle,
265  &requestedSize);
266 
267  request.fullscreen = false;
268  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
269 
270  ActualWindowSize actual_size =
271  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
272  EXPECT_EQ(actual_size.width, 500);
273  EXPECT_EQ(actual_size.height, 500);
274 }
InternalFlutterWindows_WindowManager_SetWindowSize
void InternalFlutterWindows_WindowManager_SetWindowSize(HWND hwnd, const flutter::WindowSizeRequest *size)
Definition: window_manager.cc:184

References flutter::FullscreenRequest::fullscreen, flutter::WindowSizeRequest::has_preferred_view_size, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetFullscreen(), InternalFlutterWindows_WindowManager_SetWindowSize(), and flutter::ActualWindowSize::width.

◆ TEST_F() [152/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CanUnfullscreenWindow   
)

Definition at line 221 of file window_manager_unittests.cc.

221  {
222  IsolateScope isolate_scope(isolate());
223 
224  const int64_t view_id =
225  InternalFlutterWindows_WindowManager_CreateRegularWindow(
226  engine_id(), regular_creation_request());
227  const HWND window_handle =
228  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
229  view_id);
230 
231  FullscreenRequest request{.fullscreen = true, .has_display_id = false};
232  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
233 
234  request.fullscreen = false;
235  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
236 
237  ActualWindowSize actual_size =
238  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
239  EXPECT_EQ(actual_size.width, 800);
240  EXPECT_EQ(actual_size.height, 600);
241  EXPECT_FALSE(
242  InternalFlutterWindows_WindowManager_GetFullscreen(window_handle));
243 }

References flutter::FullscreenRequest::fullscreen, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetFullscreen(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetFullscreen(), and flutter::ActualWindowSize::width.

◆ TEST_F() [153/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CreateModalDialogWindow   
)

Definition at line 321 of file window_manager_unittests.cc.

321  {
322  IsolateScope isolate_scope(isolate());
323 
324  const int64_t parent_view_id =
325  InternalFlutterWindows_WindowManager_CreateRegularWindow(
326  engine_id(), regular_creation_request());
327  const HWND parent_window_handle =
328  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
329  engine_id(), parent_view_id);
330 
331  DialogWindowCreationRequest creation_request{
332  .preferred_size =
333  {
334  .has_preferred_view_size = true,
335  .preferred_view_width = 800,
336  .preferred_view_height = 600,
337  },
338  .preferred_constraints = {.has_view_constraints = false},
339  .title = L"Hello World",
340  .parent_or_null = parent_window_handle};
341 
342  const int64_t view_id =
343  InternalFlutterWindows_WindowManager_CreateDialogWindow(
344  engine_id(), &creation_request);
345  EXPECT_EQ(view_id, 1);
346 
347  const HWND window_handle =
348  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
349  view_id);
350  HostWindow* host_window = HostWindow::GetThisFromHandle(window_handle);
351  EXPECT_EQ(host_window->GetOwnerWindow()->GetWindowHandle(),
352  parent_window_handle);
353 }
InternalFlutterWindows_WindowManager_CreateDialogWindow
FLUTTER_EXPORT FlutterViewId InternalFlutterWindows_WindowManager_CreateDialogWindow(int64_t engine_id, const flutter::DialogWindowCreationRequest *request)
Definition: window_manager.cc:149

References flutter::HostWindow::GetOwnerWindow(), flutter::HostWindow::GetThisFromHandle(), flutter::HostWindow::GetWindowHandle(), flutter::WindowSizeRequest::has_preferred_view_size, InternalFlutterWindows_WindowManager_CreateDialogWindow(), InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), and flutter::DialogWindowCreationRequest::preferred_size.

◆ TEST_F() [154/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CreateModelessDialogWindow   
)

Definition at line 306 of file window_manager_unittests.cc.

306  {
307  IsolateScope isolate_scope(isolate());
308  DialogWindowCreationRequest creation_request{
309  .preferred_size = {.has_preferred_view_size = true,
310  .preferred_view_width = 800,
311  .preferred_view_height = 600},
312  .preferred_constraints = {.has_view_constraints = false},
313  .title = L"Hello World",
314  .parent_or_null = nullptr};
315  const int64_t view_id =
316  InternalFlutterWindows_WindowManager_CreateDialogWindow(
317  engine_id(), &creation_request);
318  EXPECT_EQ(view_id, 0);
319 }

References flutter::WindowSizeRequest::has_preferred_view_size, InternalFlutterWindows_WindowManager_CreateDialogWindow(), and flutter::DialogWindowCreationRequest::preferred_size.

◆ TEST_F() [155/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CreateRegularWindow   
)

Definition at line 87 of file window_manager_unittests.cc.

87  {
88  IsolateScope isolate_scope(isolate());
89 
90  const int64_t view_id =
91  InternalFlutterWindows_WindowManager_CreateRegularWindow(
92  engine_id(), regular_creation_request());
93  EXPECT_EQ(view_id, 0);
94 }

References InternalFlutterWindows_WindowManager_CreateRegularWindow().

◆ TEST_F() [156/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
CreateTooltipWindow   
)

Definition at line 379 of file window_manager_unittests.cc.

379  {
380  IsolateScope isolate_scope(isolate());
381 
382  const int64_t parent_view_id =
383  InternalFlutterWindows_WindowManager_CreateRegularWindow(
384  engine_id(), regular_creation_request());
385  const HWND parent_window_handle =
386  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
387  engine_id(), parent_view_id);
388 
389  auto position_callback = [](const WindowSize& child_size,
390  const WindowRect& parent_rect,
391  const WindowRect& output_rect) -> WindowRect* {
392  WindowRect* rect = static_cast<WindowRect*>(malloc(sizeof(WindowRect)));
393  rect->left = parent_rect.left + 10;
394  rect->top = parent_rect.top + 10;
395  rect->width = child_size.width;
396  rect->height = child_size.height;
397  return rect;
398  };
399 
400  TooltipWindowCreationRequest creation_request{
401  .preferred_constraints = {.has_view_constraints = true,
402  .view_min_width = 100,
403  .view_min_height = 50,
404  .view_max_width = 300,
405  .view_max_height = 200},
406  .parent = parent_window_handle,
407  .get_position_callback = position_callback};
408 
409  const int64_t tooltip_view_id =
410  InternalFlutterWindows_WindowManager_CreateTooltipWindow(
411  engine_id(), &creation_request);
412 
413  EXPECT_NE(tooltip_view_id, -1);
414  HWND tooltip_window_handle =
415  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
416  engine_id(), tooltip_view_id);
417  EXPECT_NE(tooltip_window_handle, nullptr);
418 }
InternalFlutterWindows_WindowManager_CreateTooltipWindow
FLUTTER_EXPORT FlutterViewId InternalFlutterWindows_WindowManager_CreateTooltipWindow(int64_t engine_id, const flutter::TooltipWindowCreationRequest *request)
Definition: window_manager.cc:158

References flutter::WindowConstraints::has_view_constraints, flutter::WindowRect::height, flutter::WindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), flutter::WindowRect::left, flutter::TooltipWindowCreationRequest::preferred_constraints, flutter::WindowRect::top, flutter::WindowRect::width, and flutter::WindowSize::width.

◆ TEST_F() [157/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
DialogCanNeverBeFullscreen   
)

Definition at line 355 of file window_manager_unittests.cc.

355  {
356  IsolateScope isolate_scope(isolate());
357 
358  DialogWindowCreationRequest creation_request{
359  .preferred_size = {.has_preferred_view_size = true,
360  .preferred_view_width = 800,
361  .preferred_view_height = 600},
362  .preferred_constraints = {.has_view_constraints = false},
363  .title = L"Hello World",
364  .parent_or_null = nullptr};
365 
366  const int64_t view_id =
367  InternalFlutterWindows_WindowManager_CreateDialogWindow(
368  engine_id(), &creation_request);
369  const HWND window_handle =
370  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
371  view_id);
372 
373  FullscreenRequest request{.fullscreen = true, .has_display_id = false};
374  InternalFlutterWindows_WindowManager_SetFullscreen(window_handle, &request);
375  EXPECT_FALSE(
376  InternalFlutterWindows_WindowManager_GetFullscreen(window_handle));
377 }

References flutter::FullscreenRequest::fullscreen, flutter::WindowSizeRequest::has_preferred_view_size, InternalFlutterWindows_WindowManager_CreateDialogWindow(), InternalFlutterWindows_WindowManager_GetFullscreen(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_SetFullscreen(), and flutter::DialogWindowCreationRequest::preferred_size.

◆ TEST_F() [158/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
GetWindowHandle   
)

Definition at line 96 of file window_manager_unittests.cc.

96  {
97  IsolateScope isolate_scope(isolate());
98 
99  const int64_t view_id =
100  InternalFlutterWindows_WindowManager_CreateRegularWindow(
101  engine_id(), regular_creation_request());
102  const HWND window_handle =
103  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
104  view_id);
105  EXPECT_NE(window_handle, nullptr);
106 }

References InternalFlutterWindows_WindowManager_CreateRegularWindow(), and InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle().

◆ TEST_F() [159/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
GetWindowSize   
)

Definition at line 108 of file window_manager_unittests.cc.

108  {
109  IsolateScope isolate_scope(isolate());
110 
111  const int64_t view_id =
112  InternalFlutterWindows_WindowManager_CreateRegularWindow(
113  engine_id(), regular_creation_request());
114  const HWND window_handle =
115  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
116  view_id);
117 
118  ActualWindowSize size =
119  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
120 
121  EXPECT_EQ(size.width,
122  regular_creation_request()->preferred_size.preferred_view_width);
123  EXPECT_EQ(size.height,
124  regular_creation_request()->preferred_size.preferred_view_height);
125 }

References flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), and flutter::ActualWindowSize::width.

◆ TEST_F() [160/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
SetWindowSize   
)

Definition at line 127 of file window_manager_unittests.cc.

127  {
128  IsolateScope isolate_scope(isolate());
129 
130  const int64_t view_id =
131  InternalFlutterWindows_WindowManager_CreateRegularWindow(
132  engine_id(), regular_creation_request());
133  const HWND window_handle =
134  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(engine_id(),
135  view_id);
136 
137  WindowSizeRequest requestedSize{
138 
139  .has_preferred_view_size = true,
140  .preferred_view_width = 640,
141  .preferred_view_height = 480,
142  };
143  InternalFlutterWindows_WindowManager_SetWindowSize(window_handle,
144  &requestedSize);
145 
146  ActualWindowSize actual_size =
147  InternalFlutterWindows_WindowManager_GetWindowContentSize(window_handle);
148  EXPECT_EQ(actual_size.width, 640);
149  EXPECT_EQ(actual_size.height, 480);
150 }

References flutter::WindowSizeRequest::has_preferred_view_size, flutter::ActualWindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_GetWindowContentSize(), InternalFlutterWindows_WindowManager_SetWindowSize(), and flutter::ActualWindowSize::width.

◆ TEST_F() [161/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
TooltipWindowDoesNotStealFocus   
)

Definition at line 462 of file window_manager_unittests.cc.

462  {
463  IsolateScope isolate_scope(isolate());
464 
465  const int64_t parent_view_id =
466  InternalFlutterWindows_WindowManager_CreateRegularWindow(
467  engine_id(), regular_creation_request());
468  const HWND parent_window_handle =
469  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
470  engine_id(), parent_view_id);
471 
472  // Give focus to the parent window
473  SetFocus(parent_window_handle);
474  HWND focused_before = GetFocus();
475 
476  auto position_callback = [](const WindowSize& child_size,
477  const WindowRect& parent_rect,
478  const WindowRect& output_rect) -> WindowRect* {
479  WindowRect* rect = static_cast<WindowRect*>(malloc(sizeof(WindowRect)));
480  rect->left = parent_rect.left + 10;
481  rect->top = parent_rect.top + 10;
482  rect->width = child_size.width;
483  rect->height = child_size.height;
484  return rect;
485  };
486 
487  TooltipWindowCreationRequest creation_request{
488  .preferred_constraints = {.has_view_constraints = true,
489  .view_min_width = 100,
490  .view_min_height = 50,
491  .view_max_width = 300,
492  .view_max_height = 200},
493  .parent = parent_window_handle,
494  .get_position_callback = position_callback};
495 
496  const int64_t tooltip_view_id =
497  InternalFlutterWindows_WindowManager_CreateTooltipWindow(
498  engine_id(), &creation_request);
499 
500  HWND tooltip_window_handle =
501  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
502  engine_id(), tooltip_view_id);
503 
504  // Verify focus remains with the parent window
505  HWND focused_after = GetFocus();
506  EXPECT_EQ(focused_before, focused_after);
507  EXPECT_NE(focused_after, tooltip_window_handle);
508 }

References flutter::WindowConstraints::has_view_constraints, flutter::WindowRect::height, flutter::WindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), flutter::WindowRect::left, flutter::TooltipWindowCreationRequest::preferred_constraints, flutter::WindowRect::top, flutter::WindowRect::width, and flutter::WindowSize::width.

◆ TEST_F() [162/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
TooltipWindowHasNoActivateStyle   
)

Definition at line 420 of file window_manager_unittests.cc.

420  {
421  IsolateScope isolate_scope(isolate());
422 
423  const int64_t parent_view_id =
424  InternalFlutterWindows_WindowManager_CreateRegularWindow(
425  engine_id(), regular_creation_request());
426  const HWND parent_window_handle =
427  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
428  engine_id(), parent_view_id);
429 
430  auto position_callback = [](const WindowSize& child_size,
431  const WindowRect& parent_rect,
432  const WindowRect& output_rect) -> WindowRect* {
433  WindowRect* rect = static_cast<WindowRect*>(malloc(sizeof(WindowRect)));
434  rect->left = parent_rect.left + 10;
435  rect->top = parent_rect.top + 10;
436  rect->width = child_size.width;
437  rect->height = child_size.height;
438  return rect;
439  };
440 
441  TooltipWindowCreationRequest creation_request{
442  .preferred_constraints = {.has_view_constraints = true,
443  .view_min_width = 100,
444  .view_min_height = 50,
445  .view_max_width = 300,
446  .view_max_height = 200},
447  .parent = parent_window_handle,
448  .get_position_callback = position_callback};
449 
450  const int64_t tooltip_view_id =
451  InternalFlutterWindows_WindowManager_CreateTooltipWindow(
452  engine_id(), &creation_request);
453 
454  HWND tooltip_window_handle =
455  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
456  engine_id(), tooltip_view_id);
457 
458  DWORD ex_style = GetWindowLong(tooltip_window_handle, GWL_EXSTYLE);
459  EXPECT_TRUE(ex_style & WS_EX_NOACTIVATE);
460 }

References flutter::WindowConstraints::has_view_constraints, flutter::WindowRect::height, flutter::WindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), flutter::WindowRect::left, flutter::TooltipWindowCreationRequest::preferred_constraints, flutter::WindowRect::top, flutter::WindowRect::width, and flutter::WindowSize::width.

◆ TEST_F() [163/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
TooltipWindowReturnsNoActivateOnMouseClick   
)

Definition at line 510 of file window_manager_unittests.cc.

510  {
511  IsolateScope isolate_scope(isolate());
512 
513  const int64_t parent_view_id =
514  InternalFlutterWindows_WindowManager_CreateRegularWindow(
515  engine_id(), regular_creation_request());
516  const HWND parent_window_handle =
517  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
518  engine_id(), parent_view_id);
519 
520  auto position_callback = [](const WindowSize& child_size,
521  const WindowRect& parent_rect,
522  const WindowRect& output_rect) -> WindowRect* {
523  WindowRect* rect = static_cast<WindowRect*>(malloc(sizeof(WindowRect)));
524  rect->left = parent_rect.left + 10;
525  rect->top = parent_rect.top + 10;
526  rect->width = child_size.width;
527  rect->height = child_size.height;
528  return rect;
529  };
530 
531  TooltipWindowCreationRequest creation_request{
532  .preferred_constraints = {.has_view_constraints = true,
533  .view_min_width = 100,
534  .view_min_height = 50,
535  .view_max_width = 300,
536  .view_max_height = 200},
537  .parent = parent_window_handle,
538  .get_position_callback = position_callback};
539 
540  const int64_t tooltip_view_id =
541  InternalFlutterWindows_WindowManager_CreateTooltipWindow(
542  engine_id(), &creation_request);
543 
544  HWND tooltip_window_handle =
545  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
546  engine_id(), tooltip_view_id);
547 
548  // Send WM_MOUSEACTIVATE message to the tooltip window
549  LRESULT result = SendMessage(tooltip_window_handle, WM_MOUSEACTIVATE,
550  reinterpret_cast<WPARAM>(parent_window_handle),
551  MAKELPARAM(HTCLIENT, WM_LBUTTONDOWN));
552 
553  // Verify the tooltip returns MA_NOACTIVATE
554  EXPECT_EQ(result, MA_NOACTIVATE);
555 }

References flutter::WindowConstraints::has_view_constraints, flutter::WindowRect::height, flutter::WindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), flutter::WindowRect::left, flutter::TooltipWindowCreationRequest::preferred_constraints, flutter::WindowRect::top, flutter::WindowRect::width, and flutter::WindowSize::width.

◆ TEST_F() [164/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
TooltipWindowUpdatesPositionOnViewSizeChange   
)

Definition at line 557 of file window_manager_unittests.cc.

557  {
558  IsolateScope isolate_scope(isolate());
559 
560  const int64_t parent_view_id =
561  InternalFlutterWindows_WindowManager_CreateRegularWindow(
562  engine_id(), regular_creation_request());
563  const HWND parent_window_handle =
564  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
565  engine_id(), parent_view_id);
566 
567  // Track the child size passed to the callback
568  static int callback_count = 0;
569  static int last_width = 0;
570  static int last_height = 0;
571 
572  auto position_callback = [](const WindowSize& child_size,
573  const WindowRect& parent_rect,
574  const WindowRect& output_rect) -> WindowRect* {
575  callback_count++;
576  last_width = child_size.width;
577  last_height = child_size.height;
578 
579  // Use malloc since the caller will use free()
580  WindowRect* rect = static_cast<WindowRect*>(malloc(sizeof(WindowRect)));
581  rect->left = parent_rect.left + callback_count * 5;
582  rect->top = parent_rect.top + callback_count * 5;
583  rect->width = child_size.width;
584  rect->height = child_size.height;
585  return rect;
586  };
587 
588  TooltipWindowCreationRequest creation_request{
589  .preferred_constraints = {.has_view_constraints = true,
590  .view_min_width = 100,
591  .view_min_height = 50,
592  .view_max_width = 300,
593  .view_max_height = 200},
594  .is_sized_to_content = true,
595  .parent = parent_window_handle,
596  .get_position_callback = position_callback};
597 
598  // Reset callback tracking
599  callback_count = 0;
600  last_width = 0;
601  last_height = 0;
602 
603  const int64_t tooltip_view_id =
604  InternalFlutterWindows_WindowManager_CreateTooltipWindow(
605  engine_id(), &creation_request);
606 
607  HWND tooltip_window_handle =
608  InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
609  engine_id(), tooltip_view_id);
610 
611  // Get the view associated with the tooltip window
612  FlutterWindowsView* view =
613  engine()->GetViewFromTopLevelWindow(tooltip_window_handle);
614  ASSERT_NE(view, nullptr);
615 
616  // Get initial position
617  RECT initial_rect;
618  GetWindowRect(tooltip_window_handle, &initial_rect);
619  int initial_callback_count = callback_count;
620 
621  // Simulate a frame being generated with new dimensions
622  // This should trigger DidUpdateViewSize which calls UpdatePosition
623  view->OnFrameGenerated(150, 100);
624 
625  // Process any pending tasks to ensure the callback is executed
626  engine()->task_runner()->ProcessTasks();
627 
628  // Verify the callback was called again with the new dimensions
629  EXPECT_GT(callback_count, initial_callback_count);
630  EXPECT_EQ(last_width, 150);
631  EXPECT_EQ(last_height, 100);
632 
633  // Get new position and verify it changed
634  RECT new_rect;
635  GetWindowRect(tooltip_window_handle, &new_rect);
636 
637  // The position should have changed due to our callback logic
638  // (we offset by callback_count * 5)
639  EXPECT_NE(initial_rect.left, new_rect.left);
640  EXPECT_NE(initial_rect.top, new_rect.top);
641 }

References flutter::WindowConstraints::has_view_constraints, flutter::WindowRect::height, flutter::WindowSize::height, InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), flutter::WindowRect::left, flutter::FlutterWindowsView::OnFrameGenerated(), flutter::TooltipWindowCreationRequest::preferred_constraints, flutter::WindowRect::top, flutter::WindowRect::width, and flutter::WindowSize::width.

◆ TEST_F() [165/192]

flutter::testing::TEST_F ( WindowManagerTest  ,
WindowingInitialize   
)

Definition at line 70 of file window_manager_unittests.cc.

70  {
71  IsolateScope isolate_scope(isolate());
72 
73  static bool received_message = false;
74  WindowingInitRequest init_request{
75  .on_message = [](WindowsMessage* message) { received_message = true; }};
76 
77  InternalFlutterWindows_WindowManager_Initialize(engine_id(), &init_request);
78  const int64_t view_id =
79  InternalFlutterWindows_WindowManager_CreateRegularWindow(
80  engine_id(), regular_creation_request());
81  DestroyWindow(InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(
82  engine_id(), view_id));
83 
84  EXPECT_TRUE(received_message);
85 }
InternalFlutterWindows_WindowManager_Initialize
void InternalFlutterWindows_WindowManager_Initialize(int64_t engine_id, const flutter::WindowingInitRequest *request)
Definition: window_manager.cc:132

References InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), InternalFlutterWindows_WindowManager_Initialize(), message, and flutter::WindowingInitRequest::on_message.

◆ TEST_F() [166/192]

flutter::testing::TEST_F ( WindowsLifecycleManagerTest  ,
StateTransitions   
)

Definition at line 26 of file windows_lifecycle_manager_unittests.cc.

26  {
27  FlutterWindowsEngineBuilder builder{GetContext()};
28  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
29 
30  WindowsLifecycleManager manager{engine.get()};
31  HWND win1 = reinterpret_cast<HWND>(1);
32  HWND win2 = reinterpret_cast<HWND>(2);
33 
34  // Hidden to inactive upon window shown.
35  manager.SetLifecycleState(AppLifecycleState::kHidden);
36  manager.OnWindowStateEvent(win1, WindowStateEvent::kShow);
37  WaitUntilUpdated(manager);
38  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
39 
40  // Showing a second window does not change state.
41  manager.OnWindowStateEvent(win2, WindowStateEvent::kShow);
42  WaitUntilUpdated(manager);
43  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
44 
45  // Inactive to resumed upon window focus.
46  manager.OnWindowStateEvent(win2, WindowStateEvent::kFocus);
47  WaitUntilUpdated(manager);
48  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
49 
50  // Showing a second window does not change state.
51  manager.OnWindowStateEvent(win1, WindowStateEvent::kFocus);
52  WaitUntilUpdated(manager);
53  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
54 
55  // Unfocusing one window does not change state while another is focused.
56  manager.OnWindowStateEvent(win1, WindowStateEvent::kUnfocus);
57  WaitUntilUpdated(manager);
58  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
59 
60  // Unfocusing final remaining focused window transitions to inactive.
61  manager.OnWindowStateEvent(win2, WindowStateEvent::kUnfocus);
62  WaitUntilUpdated(manager);
63  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
64 
65  // Hiding one of two visible windows does not change state.
66  manager.OnWindowStateEvent(win2, WindowStateEvent::kHide);
67  WaitUntilUpdated(manager);
68  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
69 
70  // Hiding only visible window transitions to hidden.
71  manager.OnWindowStateEvent(win1, WindowStateEvent::kHide);
72  WaitUntilUpdated(manager);
73  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kHidden);
74 
75  // Transition directly from resumed to hidden when the window is hidden.
76  manager.OnWindowStateEvent(win1, WindowStateEvent::kShow);
77  manager.OnWindowStateEvent(win1, WindowStateEvent::kFocus);
78  manager.OnWindowStateEvent(win1, WindowStateEvent::kHide);
79  WaitUntilUpdated(manager);
80  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kHidden);
81 }
flutter::testing::WaitUntilUpdated
static void WaitUntilUpdated(const WindowsLifecycleManager &manager)
Definition: windows_lifecycle_manager_unittests.cc:16

References flutter::kFocus, flutter::kHidden, flutter::kHide, flutter::kInactive, flutter::kResumed, flutter::kShow, flutter::kUnfocus, flutter::WindowsLifecycleManager::SetLifecycleState(), and WaitUntilUpdated().

◆ TEST_F() [167/192]

flutter::testing::TEST_F ( WindowsTest  ,
AddRemoveView   
)

Definition at line 640 of file flutter_windows_unittests.cc.

640  {
641  std::mutex mutex;
642  std::string view_ids;
643 
644  auto& context = GetContext();
645  WindowsConfigBuilder builder(context);
646  builder.SetDartEntrypoint("onMetricsChangedSignalViewIds");
647 
648  bool ready = false;
649  context.AddNativeFunction(
650  "Signal",
651  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { ready = true; }));
652 
653  context.AddNativeFunction(
654  "SignalStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
655  auto handle = Dart_GetNativeArgument(args, 0);
656  ASSERT_FALSE(Dart_IsError(handle));
657 
658  std::scoped_lock lock{mutex};
659  view_ids = tonic::DartConverter<std::string>::FromDart(handle);
660  }));
661 
662  // Create the implicit view.
663  ViewControllerPtr first_controller{builder.Run()};
664  ASSERT_NE(first_controller, nullptr);
665 
666  while (!ready) {
667  PumpMessage();
668  }
669 
670  // Create a second view.
671  FlutterDesktopEngineRef engine =
672  FlutterDesktopViewControllerGetEngine(first_controller.get());
673  FlutterDesktopViewControllerProperties properties = {};
674  properties.width = 100;
675  properties.height = 100;
676  ViewControllerPtr second_controller{
677  FlutterDesktopEngineCreateViewController(engine, &properties)};
678  ASSERT_NE(second_controller, nullptr);
679 
680  // Pump messages for the Windows platform task runner until the view is added.
681  while (true) {
682  PumpMessage();
683  std::scoped_lock lock{mutex};
684  if (view_ids == "View IDs: [0, 1]") {
685  break;
686  }
687  }
688 
689  // Delete the second view and pump messages for the Windows platform task
690  // runner until the view is removed.
691  second_controller.reset();
692  while (true) {
693  PumpMessage();
694  std::scoped_lock lock{mutex};
695  if (view_ids == "View IDs: [0]") {
696  break;
697  }
698  }
699 }
FlutterDesktopEngineCreateViewController
FlutterDesktopViewControllerRef FlutterDesktopEngineCreateViewController(FlutterDesktopEngineRef engine, const FlutterDesktopViewControllerProperties *properties)
Definition: flutter_windows.cc:129
FlutterDesktopEngineRef
struct FlutterDesktopEngine * FlutterDesktopEngineRef
Definition: flutter_windows.h:33

References FlutterDesktopEngineCreateViewController(), FlutterDesktopViewControllerGetEngine(), FlutterDesktopViewControllerProperties::height, and FlutterDesktopViewControllerProperties::width.

◆ TEST_F() [168/192]

flutter::testing::TEST_F ( WindowsTest  ,
EngineCanTransitionToHeadless   
)

Definition at line 153 of file flutter_windows_unittests.cc.

153  {
154  auto& context = GetContext();
155  WindowsConfigBuilder builder(context);
156  EnginePtr engine{builder.RunHeadless()};
157  ASSERT_NE(engine, nullptr);
158 
159  // Create and then destroy a view controller that does not own its engine.
160  // This causes the engine to transition back to headless mode.
161  {
162  FlutterDesktopViewControllerProperties properties = {};
163  ViewControllerPtr controller{
164  FlutterDesktopEngineCreateViewController(engine.get(), &properties)};
165 
166  ASSERT_NE(controller, nullptr);
167  }
168 
169  // The engine is back in headless mode now.
170  ASSERT_NE(engine, nullptr);
171 
172  auto engine_ptr = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
173  ASSERT_TRUE(engine_ptr->running());
174 }

References FlutterDesktopEngineCreateViewController().

◆ TEST_F() [169/192]

flutter::testing::TEST_F ( WindowsTest  ,
EngineId   
)

Definition at line 701 of file flutter_windows_unittests.cc.

701  {
702  auto& context = GetContext();
703  WindowsConfigBuilder builder(context);
704  builder.SetDartEntrypoint("testEngineId");
705 
706  std::optional<int64_t> engineId;
707  context.AddNativeFunction(
708  "NotifyEngineId", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
709  const auto argument = Dart_GetNativeArgument(args, 0);
710  if (!Dart_IsNull(argument)) {
711  const auto handle = tonic::DartConverter<int64_t>::FromDart(argument);
712  engineId = handle;
713  }
714  }));
715  // Create the implicit view.
716  ViewControllerPtr first_controller{builder.Run()};
717  ASSERT_NE(first_controller, nullptr);
718 
719  while (!engineId.has_value()) {
720  PumpMessage();
721  }
722 
723  auto engine = FlutterDesktopViewControllerGetEngine(first_controller.get());
724  EXPECT_EQ(engine, FlutterDesktopEngineForId(*engineId));
725 }
FlutterDesktopEngineForId
FLUTTER_EXPORT FlutterDesktopEngineRef FlutterDesktopEngineForId(int64_t engine_id)
Definition: flutter_windows.cc:202

References FlutterDesktopEngineForId(), and FlutterDesktopViewControllerGetEngine().

◆ TEST_F() [170/192]

flutter::testing::TEST_F ( WindowsTest  ,
GetGraphicsAdapter   
)

Definition at line 419 of file flutter_windows_unittests.cc.

419  {
420  auto& context = GetContext();
421  WindowsConfigBuilder builder(context);
422  ViewControllerPtr controller{builder.Run()};
423  ASSERT_NE(controller, nullptr);
424  auto view = FlutterDesktopViewControllerGetView(controller.get());
425 
426  Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
427  dxgi_adapter = FlutterDesktopViewGetGraphicsAdapter(view);
428  ASSERT_NE(dxgi_adapter, nullptr);
429  DXGI_ADAPTER_DESC desc{};
430  ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
431 }
FlutterDesktopViewGetGraphicsAdapter
IDXGIAdapter * FlutterDesktopViewGetGraphicsAdapter(FlutterDesktopViewRef view)
Definition: flutter_windows.cc:257
FlutterDesktopViewControllerGetView
FlutterDesktopViewRef FlutterDesktopViewControllerGetView(FlutterDesktopViewControllerRef ref)
Definition: flutter_windows.cc:154

References FlutterDesktopViewControllerGetView(), and FlutterDesktopViewGetGraphicsAdapter().

◆ TEST_F() [171/192]

flutter::testing::TEST_F ( WindowsTest  ,
GetGraphicsAdapterWithHighPerformancePreference   
)

Definition at line 455 of file flutter_windows_unittests.cc.

455  {
456  std::optional<LUID> luid = egl::Manager::GetHighPerformanceGpuLuid();
457  if (!luid) {
458  GTEST_SKIP() << "Not able to find high performance GPU, nothing to check.";
459  }
460 
461  auto& context = GetContext();
462  WindowsConfigBuilder builder(context);
463  builder.SetGpuPreference(
464  FlutterDesktopGpuPreference::HighPerformancePreference);
465  ViewControllerPtr controller{builder.Run()};
466  ASSERT_NE(controller, nullptr);
467  auto view = FlutterDesktopViewControllerGetView(controller.get());
468 
469  Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
470  dxgi_adapter = FlutterDesktopViewGetGraphicsAdapter(view);
471  ASSERT_NE(dxgi_adapter, nullptr);
472  DXGI_ADAPTER_DESC desc{};
473  ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
474  ASSERT_EQ(desc.AdapterLuid.HighPart, luid->HighPart);
475  ASSERT_EQ(desc.AdapterLuid.LowPart, luid->LowPart);
476 }
HighPerformancePreference
@ HighPerformancePreference
Definition: flutter_windows.h:49

References FlutterDesktopViewControllerGetView(), FlutterDesktopViewGetGraphicsAdapter(), flutter::egl::Manager::GetHighPerformanceGpuLuid(), and HighPerformancePreference.

◆ TEST_F() [172/192]

flutter::testing::TEST_F ( WindowsTest  ,
GetGraphicsAdapterWithLowPowerPreference   
)

Definition at line 433 of file flutter_windows_unittests.cc.

433  {
434  std::optional<LUID> luid = egl::Manager::GetLowPowerGpuLuid();
435  if (!luid) {
436  GTEST_SKIP() << "Not able to find low power GPU, nothing to check.";
437  }
438 
439  auto& context = GetContext();
440  WindowsConfigBuilder builder(context);
441  builder.SetGpuPreference(FlutterDesktopGpuPreference::LowPowerPreference);
442  ViewControllerPtr controller{builder.Run()};
443  ASSERT_NE(controller, nullptr);
444  auto view = FlutterDesktopViewControllerGetView(controller.get());
445 
446  Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
447  dxgi_adapter = FlutterDesktopViewGetGraphicsAdapter(view);
448  ASSERT_NE(dxgi_adapter, nullptr);
449  DXGI_ADAPTER_DESC desc{};
450  ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
451  ASSERT_EQ(desc.AdapterLuid.HighPart, luid->HighPart);
452  ASSERT_EQ(desc.AdapterLuid.LowPart, luid->LowPart);
453 }
LowPowerPreference
@ LowPowerPreference
Definition: flutter_windows.h:45

References FlutterDesktopViewControllerGetView(), FlutterDesktopViewGetGraphicsAdapter(), flutter::egl::Manager::GetLowPowerGpuLuid(), and LowPowerPreference.

◆ TEST_F() [173/192]

flutter::testing::TEST_F ( WindowsTest  ,
GetKeyboardStateHeadless   
)

Definition at line 614 of file flutter_windows_unittests.cc.

614  {
615  auto& context = GetContext();
616  WindowsConfigBuilder builder(context);
617  builder.SetDartEntrypoint("sendGetKeyboardState");
618 
619  std::atomic<bool> done = false;
620  context.AddNativeFunction(
621  "SignalStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
622  auto handle = Dart_GetNativeArgument(args, 0);
623  ASSERT_FALSE(Dart_IsError(handle));
624  auto value = tonic::DartConverter<std::string>::FromDart(handle);
625  EXPECT_EQ(value, "Success");
626  done = true;
627  }));
628 
629  ViewControllerPtr controller{builder.Run()};
630  ASSERT_NE(controller, nullptr);
631 
632  // Pump messages for the Windows platform task runner.
633  ::MSG msg;
634  while (!done) {
635  PumpMessage();
636  }
637 }

◆ TEST_F() [174/192]

flutter::testing::TEST_F ( WindowsTest  ,
GetViewId   
)

Definition at line 408 of file flutter_windows_unittests.cc.

408  {
409  auto& context = GetContext();
410  WindowsConfigBuilder builder(context);
411  ViewControllerPtr controller{builder.Run()};
412  ASSERT_NE(controller, nullptr);
413  FlutterDesktopViewId view_id =
414  FlutterDesktopViewControllerGetViewId(controller.get());
415 
416  ASSERT_EQ(view_id, static_cast<FlutterDesktopViewId>(kImplicitViewId));
417 }
FlutterDesktopViewControllerGetViewId
FlutterDesktopViewId FlutterDesktopViewControllerGetViewId(FlutterDesktopViewControllerRef ref)
Definition: flutter_windows.cc:142
FlutterDesktopViewId
int64_t FlutterDesktopViewId
Definition: flutter_windows.h:36

References FlutterDesktopViewControllerGetViewId(), and flutter::kImplicitViewId.

◆ TEST_F() [175/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchConflictingCustomEntrypoints   
)

Definition at line 202 of file flutter_windows_unittests.cc.

202  {
203  auto& context = GetContext();
204  WindowsConfigBuilder builder(context);
205  builder.SetDartEntrypoint("customEntrypoint");
206  EnginePtr engine{builder.InitializeEngine()};
207  ASSERT_NE(engine, nullptr);
208 
209  ASSERT_FALSE(FlutterDesktopEngineRun(engine.get(), "conflictingEntrypoint"));
210 }
FlutterDesktopEngineRun
bool FlutterDesktopEngineRun(FlutterDesktopEngineRef engine, const char *entry_point)
Definition: flutter_windows.cc:207

References FlutterDesktopEngineRun().

◆ TEST_F() [176/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchCustomEntrypoint   
)

Definition at line 101 of file flutter_windows_unittests.cc.

101  {
102  auto& context = GetContext();
103  WindowsConfigBuilder builder(context);
104  builder.SetDartEntrypoint("customEntrypoint");
105  ViewControllerPtr controller{builder.Run()};
106  ASSERT_NE(controller, nullptr);
107 }

◆ TEST_F() [177/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchCustomEntrypointInEngineRunInvocation   
)

Definition at line 114 of file flutter_windows_unittests.cc.

114  {
115  auto& context = GetContext();
116  WindowsConfigBuilder builder(context);
117  EnginePtr engine{builder.InitializeEngine()};
118  ASSERT_NE(engine, nullptr);
119 
120  ASSERT_TRUE(FlutterDesktopEngineRun(engine.get(), "customEntrypoint"));
121 }

References FlutterDesktopEngineRun().

◆ TEST_F() [178/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchHeadlessEngine   
)

Definition at line 124 of file flutter_windows_unittests.cc.

124  {
125  auto& context = GetContext();
126  WindowsConfigBuilder builder(context);
127  builder.SetDartEntrypoint("signalViewIds");
128  EnginePtr engine{builder.RunHeadless()};
129  ASSERT_NE(engine, nullptr);
130 
131  std::string view_ids;
132  bool signaled = false;
133  context.AddNativeFunction(
134  "SignalStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
135  auto handle = Dart_GetNativeArgument(args, 0);
136  ASSERT_FALSE(Dart_IsError(handle));
137  view_ids = tonic::DartConverter<std::string>::FromDart(handle);
138  signaled = true;
139  }));
140 
141  ViewControllerPtr controller{builder.Run()};
142  ASSERT_NE(controller, nullptr);
143 
144  while (!signaled) {
145  PumpMessage();
146  }
147 
148  // Verify a headless app has the implicit view.
149  EXPECT_EQ(view_ids, "View IDs: [0]");
150 }

◆ TEST_F() [179/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchMain   
)

Definition at line 76 of file flutter_windows_unittests.cc.

76  {
77  auto& context = GetContext();
78  WindowsConfigBuilder builder(context);
79  ViewControllerPtr controller{builder.Run()};
80  ASSERT_NE(controller, nullptr);
81 }

◆ TEST_F() [180/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchMainHasNoOutput   
)

Definition at line 84 of file flutter_windows_unittests.cc.

84  {
85  // Replace stderr stream buffer with our own. (stdout may contain expected
86  // output printed by Dart, such as the Dart VM service startup message)
87  StreamCapture stderr_capture(&std::cerr);
88 
89  auto& context = GetContext();
90  WindowsConfigBuilder builder(context);
91  ViewControllerPtr controller{builder.Run()};
92  ASSERT_NE(controller, nullptr);
93 
94  stderr_capture.Stop();
95 
96  // Verify stderr has no output.
97  EXPECT_TRUE(stderr_capture.GetOutput().empty());
98 }

◆ TEST_F() [181/192]

flutter::testing::TEST_F ( WindowsTest  ,
LaunchRefreshesAccessibility   
)

Definition at line 177 of file flutter_windows_unittests.cc.

177  {
178  auto& context = GetContext();
179  WindowsConfigBuilder builder(context);
180  EnginePtr engine{builder.InitializeEngine()};
181  EngineModifier modifier{
182  reinterpret_cast<FlutterWindowsEngine*>(engine.get())};
183 
184  auto called = false;
185  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
186  UpdateAccessibilityFeatures, ([&called](auto engine, auto flags) {
187  called = true;
188  return kSuccess;
189  }));
190 
191  ViewControllerPtr controller{
192  FlutterDesktopViewControllerCreate(0, 0, engine.release())};
193 
194  ASSERT_TRUE(called);
195 }
FlutterDesktopViewControllerCreate
FlutterDesktopViewControllerRef FlutterDesktopViewControllerCreate(int width, int height, FlutterDesktopEngineRef engine)
Definition: flutter_windows.cc:122

References FlutterDesktopViewControllerCreate(), and flutter::FlutterWindowsEngine::UpdateAccessibilityFeatures().

◆ TEST_F() [182/192]

flutter::testing::TEST_F ( WindowsTest  ,
Lifecycle   
)

Definition at line 556 of file flutter_windows_unittests.cc.

556  {
557  auto& context = GetContext();
558  WindowsConfigBuilder builder(context);
559  EnginePtr engine{builder.InitializeEngine()};
560  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
561  EngineModifier modifier{windows_engine};
562 
563  auto lifecycle_manager =
564  std::make_unique<MockWindowsLifecycleManager>(windows_engine);
565  auto lifecycle_manager_ptr = lifecycle_manager.get();
566  modifier.SetLifecycleManager(std::move(lifecycle_manager));
567 
568  EXPECT_CALL(*lifecycle_manager_ptr,
569  SetLifecycleState(AppLifecycleState::kInactive))
570  .WillOnce([lifecycle_manager_ptr](AppLifecycleState state) {
571  lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
572  state);
573  });
574 
575  EXPECT_CALL(*lifecycle_manager_ptr,
576  SetLifecycleState(AppLifecycleState::kHidden))
577  .WillOnce([lifecycle_manager_ptr](AppLifecycleState state) {
578  lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
579  state);
580  });
581 
582  FlutterDesktopViewControllerProperties properties = {0, 0};
583 
584  // Create a controller. This launches the engine and sets the app lifecycle
585  // to the "resumed" state.
586  ViewControllerPtr controller{
587  FlutterDesktopEngineCreateViewController(engine.get(), &properties)};
588 
589  FlutterDesktopViewRef view =
590  FlutterDesktopViewControllerGetView(controller.get());
591  ASSERT_NE(view, nullptr);
592 
593  HWND hwnd = FlutterDesktopViewGetHWND(view);
594  ASSERT_NE(hwnd, nullptr);
595 
596  // Give the window a non-zero size to show it. This does not change the app
597  // lifecycle directly. However, destroying the view will now result in a
598  // "hidden" app lifecycle event.
599  ::MoveWindow(hwnd, /* X */ 0, /* Y */ 0, /* nWidth*/ 100, /* nHeight*/ 100,
600  /* bRepaint*/ false);
601 
602  while (lifecycle_manager_ptr->IsUpdateStateScheduled()) {
603  PumpMessage();
604  }
605 
606  // Resets the view, simulating the window being hidden.
607  controller.reset();
608 
609  while (lifecycle_manager_ptr->IsUpdateStateScheduled()) {
610  PumpMessage();
611  }
612 }
FlutterDesktopViewGetHWND
HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view)
Definition: flutter_windows.cc:253
FlutterDesktopViewRef
struct FlutterDesktopView * FlutterDesktopViewRef
Definition: flutter_windows.h:29

References FlutterDesktopEngineCreateViewController(), FlutterDesktopViewControllerGetView(), FlutterDesktopViewGetHWND(), flutter::kHidden, and flutter::kInactive.

◆ TEST_F() [183/192]

flutter::testing::TEST_F ( WindowsTest  ,
NextFrameCallback   
)

Definition at line 318 of file flutter_windows_unittests.cc.

318  {
319  struct Captures {
320  fml::AutoResetWaitableEvent frame_scheduled_latch;
321  std::thread::id thread_id;
322  bool done = false;
323  };
324  Captures captures;
325 
326  auto platform_thread = std::make_unique<fml::Thread>("test_platform_thread");
327  platform_thread->GetTaskRunner()->PostTask([&]() {
328  captures.thread_id = std::this_thread::get_id();
329 
330  auto& context = GetContext();
331  WindowsConfigBuilder builder(context);
332  builder.SetDartEntrypoint("drawHelloWorld");
333 
334  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
335  captures.frame_scheduled_latch.Signal();
336  });
337  context.AddNativeFunction("NotifyFirstFrameScheduled", native_entry);
338 
339  ViewControllerPtr controller{builder.Run()};
340  EXPECT_NE(controller, nullptr);
341 
342  auto engine = FlutterDesktopViewControllerGetEngine(controller.get());
343 
344  FlutterDesktopEngineSetNextFrameCallback(
345  engine,
346  [](void* user_data) {
347  auto captures = static_cast<Captures*>(user_data);
348 
349  EXPECT_TRUE(captures->frame_scheduled_latch.IsSignaledForTest());
350 
351  // Callback should execute on platform thread.
352  EXPECT_EQ(std::this_thread::get_id(), captures->thread_id);
353 
354  // Signal the test passed and end the Windows message loop.
355  captures->done = true;
356  },
357  &captures);
358 
359  // Pump messages for the Windows platform task runner.
360  while (!captures.done) {
361  PumpMessage();
362  }
363  });
364 
365  // Wait for the platform thread to exit.
366  platform_thread->Join();
367 }
FlutterDesktopEngineSetNextFrameCallback
void FlutterDesktopEngineSetNextFrameCallback(FlutterDesktopEngineRef engine, VoidCallback callback, void *user_data)
Definition: flutter_windows.cc:246

References FlutterDesktopEngineSetNextFrameCallback(), FlutterDesktopViewControllerGetEngine(), and user_data.

◆ TEST_F() [184/192]

flutter::testing::TEST_F ( WindowsTest  ,
PlatformExecutable   
)

Definition at line 259 of file flutter_windows_unittests.cc.

259  {
260  auto& context = GetContext();
261  WindowsConfigBuilder builder(context);
262  builder.SetDartEntrypoint("readPlatformExecutable");
263 
264  std::string executable_name;
265  bool signaled = false;
266  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
267  auto handle = Dart_GetNativeArgument(args, 0);
268  ASSERT_FALSE(Dart_IsError(handle));
269  executable_name = tonic::DartConverter<std::string>::FromDart(handle);
270  signaled = true;
271  });
272  context.AddNativeFunction("SignalStringValue", native_entry);
273 
274  ViewControllerPtr controller{builder.Run()};
275  ASSERT_NE(controller, nullptr);
276 
277  // Wait until signalStringValue has been called.
278  while (!signaled) {
279  PumpMessage();
280  }
281  EXPECT_EQ(executable_name, "flutter_windows_unittests.exe");
282 }

◆ TEST_F() [185/192]

flutter::testing::TEST_F ( WindowsTest  ,
PluginRegistrarGetImplicitView   
)

Definition at line 479 of file flutter_windows_unittests.cc.

479  {
480  auto& context = GetContext();
481  WindowsConfigBuilder builder(context);
482  ViewControllerPtr controller{builder.Run()};
483  ASSERT_NE(controller, nullptr);
484 
485  FlutterDesktopEngineRef engine =
486  FlutterDesktopViewControllerGetEngine(controller.get());
487  FlutterDesktopPluginRegistrarRef registrar =
488  FlutterDesktopEngineGetPluginRegistrar(engine, "foo_bar");
489  FlutterDesktopViewRef implicit_view =
490  FlutterDesktopPluginRegistrarGetView(registrar);
491 
492  ASSERT_NE(implicit_view, nullptr);
493 }
FlutterDesktopEngineGetPluginRegistrar
FlutterDesktopPluginRegistrarRef FlutterDesktopEngineGetPluginRegistrar(FlutterDesktopEngineRef engine, const char *plugin_name)
Definition: flutter_windows.cc:225
FlutterDesktopPluginRegistrarGetView
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(FlutterDesktopPluginRegistrarRef registrar)
Definition: flutter_windows.cc:297

References FlutterDesktopEngineGetPluginRegistrar(), FlutterDesktopPluginRegistrarGetView(), and FlutterDesktopViewControllerGetEngine().

◆ TEST_F() [186/192]

flutter::testing::TEST_F ( WindowsTest  ,
PluginRegistrarGetView   
)

Definition at line 495 of file flutter_windows_unittests.cc.

495  {
496  auto& context = GetContext();
497  WindowsConfigBuilder builder(context);
498  ViewControllerPtr controller{builder.Run()};
499  ASSERT_NE(controller, nullptr);
500 
501  FlutterDesktopEngineRef engine =
502  FlutterDesktopViewControllerGetEngine(controller.get());
503  FlutterDesktopPluginRegistrarRef registrar =
504  FlutterDesktopEngineGetPluginRegistrar(engine, "foo_bar");
505 
506  FlutterDesktopViewId view_id =
507  FlutterDesktopViewControllerGetViewId(controller.get());
508  FlutterDesktopViewRef view =
509  FlutterDesktopPluginRegistrarGetViewById(registrar, view_id);
510 
511  FlutterDesktopViewRef view_123 = FlutterDesktopPluginRegistrarGetViewById(
512  registrar, static_cast<FlutterDesktopViewId>(123));
513 
514  ASSERT_NE(view, nullptr);
515  ASSERT_EQ(view_123, nullptr);
516 }
FlutterDesktopPluginRegistrarGetViewById
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopViewId view_id)
Definition: flutter_windows.cc:302

References FlutterDesktopEngineGetPluginRegistrar(), FlutterDesktopPluginRegistrarGetViewById(), FlutterDesktopViewControllerGetEngine(), and FlutterDesktopViewControllerGetViewId().

◆ TEST_F() [187/192]

flutter::testing::TEST_F ( WindowsTest  ,
PluginRegistrarGetViewHeadless   
)

Definition at line 518 of file flutter_windows_unittests.cc.

518  {
519  auto& context = GetContext();
520  WindowsConfigBuilder builder(context);
521  EnginePtr engine{builder.RunHeadless()};
522  ASSERT_NE(engine, nullptr);
523 
524  FlutterDesktopPluginRegistrarRef registrar =
525  FlutterDesktopEngineGetPluginRegistrar(engine.get(), "foo_bar");
526 
527  FlutterDesktopViewRef implicit_view =
528  FlutterDesktopPluginRegistrarGetView(registrar);
529  FlutterDesktopViewRef view_123 = FlutterDesktopPluginRegistrarGetViewById(
530  registrar, static_cast<FlutterDesktopViewId>(123));
531 
532  ASSERT_EQ(implicit_view, nullptr);
533  ASSERT_EQ(view_123, nullptr);
534 }

References FlutterDesktopEngineGetPluginRegistrar(), FlutterDesktopPluginRegistrarGetView(), and FlutterDesktopPluginRegistrarGetViewById().

◆ TEST_F() [188/192]

flutter::testing::TEST_F ( WindowsTest  ,
PresentHeadless   
)

Definition at line 371 of file flutter_windows_unittests.cc.

371  {
372  auto& context = GetContext();
373  WindowsConfigBuilder builder(context);
374  builder.SetDartEntrypoint("renderImplicitView");
375 
376  EnginePtr engine{builder.RunHeadless()};
377  ASSERT_NE(engine, nullptr);
378 
379  bool done = false;
380  FlutterDesktopEngineSetNextFrameCallback(
381  engine.get(),
382  [](void* user_data) {
383  // This executes on the platform thread.
384  auto done = reinterpret_cast<std::atomic<bool>*>(user_data);
385  *done = true;
386  },
387  &done);
388 
389  // This app is in headless mode, however, the engine assumes the implicit
390  // view always exists. Send window metrics for the implicit view, causing
391  // the engine to present to the implicit view. The embedder must not crash.
392  auto engine_ptr = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
393  FlutterWindowMetricsEvent metrics = {};
394  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
395  metrics.width = 100;
396  metrics.height = 100;
397  metrics.pixel_ratio = 1.0;
398  metrics.view_id = kImplicitViewId;
399  engine_ptr->SendWindowMetricsEvent(metrics);
400 
401  // Pump messages for the Windows platform task runner.
402  while (!done) {
403  PumpMessage();
404  }
405 }

References FlutterDesktopEngineSetNextFrameCallback(), flutter::kImplicitViewId, and user_data.

◆ TEST_F() [189/192]

flutter::testing::TEST_F ( WindowsTest  ,
SurfaceOptional   
)

Definition at line 538 of file flutter_windows_unittests.cc.

538  {
539  auto& context = GetContext();
540  WindowsConfigBuilder builder(context);
541  EnginePtr engine{builder.InitializeEngine()};
542  EngineModifier modifier{
543  reinterpret_cast<FlutterWindowsEngine*>(engine.get())};
544 
545  auto egl_manager = std::make_unique<HalfBrokenEGLManager>();
546  ASSERT_TRUE(egl_manager->IsValid());
547  modifier.SetEGLManager(std::move(egl_manager));
548 
549  ViewControllerPtr controller{
550  FlutterDesktopViewControllerCreate(0, 0, engine.release())};
551 
552  ASSERT_NE(controller, nullptr);
553 }

References FlutterDesktopViewControllerCreate().

◆ TEST_F() [190/192]

flutter::testing::TEST_F ( WindowsTest  ,
VerifyNativeFunction   
)

Definition at line 213 of file flutter_windows_unittests.cc.

213  {
214  auto& context = GetContext();
215  WindowsConfigBuilder builder(context);
216  builder.SetDartEntrypoint("verifyNativeFunction");
217 
218  bool signaled = false;
219  auto native_entry =
220  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { signaled = true; });
221  context.AddNativeFunction("Signal", native_entry);
222 
223  ViewControllerPtr controller{builder.Run()};
224  ASSERT_NE(controller, nullptr);
225 
226  // Wait until signal has been called.
227  while (!signaled) {
228  PumpMessage();
229  }
230 }

◆ TEST_F() [191/192]

flutter::testing::TEST_F ( WindowsTest  ,
VerifyNativeFunctionWithParameters   
)

Definition at line 234 of file flutter_windows_unittests.cc.

234  {
235  auto& context = GetContext();
236  WindowsConfigBuilder builder(context);
237  builder.SetDartEntrypoint("verifyNativeFunctionWithParameters");
238 
239  bool bool_value = false;
240  bool signaled = false;
241  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
242  auto handle = Dart_GetNativeBooleanArgument(args, 0, &bool_value);
243  ASSERT_FALSE(Dart_IsError(handle));
244  signaled = true;
245  });
246  context.AddNativeFunction("SignalBoolValue", native_entry);
247 
248  ViewControllerPtr controller{builder.Run()};
249  ASSERT_NE(controller, nullptr);
250 
251  // Wait until signalBoolValue has been called.
252  while (!signaled) {
253  PumpMessage();
254  }
255  EXPECT_TRUE(bool_value);
256 }

◆ TEST_F() [192/192]

flutter::testing::TEST_F ( WindowsTest  ,
VerifyNativeFunctionWithReturn   
)

Definition at line 286 of file flutter_windows_unittests.cc.

286  {
287  auto& context = GetContext();
288  WindowsConfigBuilder builder(context);
289  builder.SetDartEntrypoint("verifyNativeFunctionWithReturn");
290 
291  bool bool_value_to_return = true;
292  int count = 2;
293  auto bool_return_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
294  Dart_SetBooleanReturnValue(args, bool_value_to_return);
295  --count;
296  });
297  context.AddNativeFunction("SignalBoolReturn", bool_return_entry);
298 
299  bool bool_value_passed = false;
300  auto bool_pass_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
301  auto handle = Dart_GetNativeBooleanArgument(args, 0, &bool_value_passed);
302  ASSERT_FALSE(Dart_IsError(handle));
303  --count;
304  });
305  context.AddNativeFunction("SignalBoolValue", bool_pass_entry);
306 
307  ViewControllerPtr controller{builder.Run()};
308  ASSERT_NE(controller, nullptr);
309 
310  // Wait until signalBoolReturn and signalBoolValue have been called.
311  while (count > 0) {
312  PumpMessage();
313  }
314  EXPECT_TRUE(bool_value_passed);
315 }

◆ VietnameseTelexAddDiacriticWithSlowResponse()

void flutter::testing::VietnameseTelexAddDiacriticWithSlowResponse ( WindowsTestContext &  context,
bool  backspace_response 
)

Definition at line 2387 of file keyboard_unittests.cc.

2388  {
2389  // In this test, the user presses the following keys:
2390  //
2391  // Key Current text
2392  // ===========================
2393  // A a
2394  // F à
2395  //
2396  // And the Backspace down event is responded slowly with `backspace_response`.
2397 
2398  KeyboardTester tester{context};
2399  tester.Responding(false);
2400 
2401  // US Keyboard layout
2402 
2403  // Press A
2404  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2405  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2406  kWmResultZero),
2407  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2408  kWmResultZero)});
2409 
2410  EXPECT_EQ(tester.key_calls.size(), 2);
2411  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2412  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2413  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2414  tester.clear_key_calls();
2415  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2416 
2417  // Release A
2418  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2419  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2420  kWmResultZero)});
2421 
2422  EXPECT_EQ(tester.key_calls.size(), 1);
2423  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2424  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2425  tester.clear_key_calls();
2426  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2427 
2428  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2429  tester.LateResponding(
2430  [&recorded_callbacks](
2431  const FlutterKeyEvent* event,
2432  MockKeyResponseController::ResponseCallback callback) {
2433  recorded_callbacks.push_back(callback);
2434  });
2435 
2436  // Press F, which is translated to:
2437  //
2438  // Backspace down, char & up, VK_PACKET('à').
2439  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2440  WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2441  kWmResultZero),
2442  WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2443  kWmResultZero),
2444  WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2445  kWmResultZero),
2446  WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2447  WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2448  WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2449 
2450  // The Backspace event has not responded yet, therefore the char message must
2451  // hold. This is because when the framework is handling the Backspace event,
2452  // it will send a setEditingState message that updates the text state that has
2453  // the last character deleted (denoted by `string1`). Processing the char
2454  // message before then will cause the final text to set to `string1`.
2455  EXPECT_EQ(tester.key_calls.size(), 1);
2456  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2457  kPhysicalBackspace, kLogicalBackspace, "",
2458  kNotSynthesized);
2459  tester.clear_key_calls();
2460  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2461 
2462  EXPECT_EQ(recorded_callbacks.size(), 1);
2463  recorded_callbacks[0](backspace_response);
2464 
2465  EXPECT_EQ(tester.key_calls.size(), 1);
2466  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2467  kPhysicalBackspace, kLogicalBackspace, "",
2468  kNotSynthesized);
2469  tester.clear_key_calls();
2470  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(),
2471  backspace_response ? 0 : 2);
2472 
2473  recorded_callbacks[1](false);
2474  EXPECT_EQ(tester.key_calls.size(), 1);
2475  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"à");
2476  tester.clear_key_calls();
2477  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2478 
2479  tester.Responding(false);
2480 
2481  // Release F
2482  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2483  WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2484  /* overwrite_prev_state_0 */ true}
2485  .Build(kWmResultZero)});
2486 
2487  EXPECT_EQ(tester.key_calls.size(), 1);
2488  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2489  kNotSynthesized);
2490  tester.clear_key_calls();
2491  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2492 }

References callback, EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

Referenced by TEST_F().

◆ WaitUntilUpdated()

static void flutter::testing::WaitUntilUpdated ( const WindowsLifecycleManager &  manager)
static

Definition at line 16 of file windows_lifecycle_manager_unittests.cc.

16  {
17  while (manager.IsUpdateStateScheduled()) {
18  ::MSG msg;
19  if (::GetMessage(&msg, nullptr, 0, 0)) {
20  ::TranslateMessage(&msg);
21  ::DispatchMessage(&msg);
22  }
23  }
24 }

References flutter::WindowsLifecycleManager::IsUpdateStateScheduled().

Referenced by TEST_F().

Variable Documentation

◆ kEmptyFlags

FlutterSemanticsFlags flutter::testing::kEmptyFlags = FlutterSemanticsFlags{}

Definition at line 18 of file accessibility_bridge_unittests.cc.

Referenced by CreateSemanticsNode().

◆ kScanCodeKeyA

constexpr uint64_t flutter::testing::kScanCodeKeyA = 0x1e
constexpr

Definition at line 42 of file flutter_windows_view_unittests.cc.

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

◆ kVirtualKeyA

constexpr uint64_t flutter::testing::kVirtualKeyA = 0x41
constexpr

Definition at line 43 of file flutter_windows_view_unittests.cc.

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