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 (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 275 of file accessibility_bridge_windows_unittests.cc.

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

References flutter::AccessibilityBridgeWindows::DispatchAccessibilityAction().

◆ TEST() [16/165]

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

Definition at line 243 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [17/165]

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

Definition at line 260 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [18/165]

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

Definition at line 300 of file accessibility_bridge_windows_unittests.cc.

300  {
301  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::ALERT,
302  ax::mojom::Event::kAlert);
303 }

◆ TEST() [19/165]

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

Definition at line 305 of file accessibility_bridge_windows_unittests.cc.

305  {
306  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::CHILDREN_CHANGED,
307  ax::mojom::Event::kChildrenChanged);
308 }

◆ TEST() [20/165]

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

Definition at line 310 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [21/165]

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

Definition at line 334 of file accessibility_bridge_windows_unittests.cc.

334  {
335  // Static test nodes with no text, hint, or scrollability are ignored.
336  ExpectWinEventFromAXEvent(4, ui::AXEventGenerator::Event::IGNORED_CHANGED,
337  ax::mojom::Event::kHide);
338 }

◆ TEST() [22/165]

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

Definition at line 356 of file accessibility_bridge_windows_unittests.cc.

356  {
357  ExpectWinEventFromAXEvent(
358  1, ui::AXEventGenerator::Event::SCROLL_HORIZONTAL_POSITION_CHANGED,
359  ax::mojom::Event::kScrollPositionChanged);
360 }

◆ TEST() [23/165]

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

Definition at line 340 of file accessibility_bridge_windows_unittests.cc.

340  {
341  ExpectWinEventFromAXEvent(
342  1, ui::AXEventGenerator::Event::IMAGE_ANNOTATION_CHANGED,
343  ax::mojom::Event::kTextChanged);
344 }

◆ TEST() [24/165]

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

Definition at line 346 of file accessibility_bridge_windows_unittests.cc.

346  {
347  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::LIVE_REGION_CHANGED,
348  ax::mojom::Event::kLiveRegionChanged);
349 }

◆ TEST() [25/165]

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

Definition at line 351 of file accessibility_bridge_windows_unittests.cc.

351  {
352  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::NAME_CHANGED,
353  ax::mojom::Event::kTextChanged);
354 }

◆ TEST() [26/165]

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

Definition at line 368 of file accessibility_bridge_windows_unittests.cc.

368  {
369  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::SELECTED_CHANGED,
370  ax::mojom::Event::kValueChanged);
371 }

◆ TEST() [27/165]

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

Definition at line 373 of file accessibility_bridge_windows_unittests.cc.

373  {
374  ExpectWinEventFromAXEvent(
375  2, ui::AXEventGenerator::Event::SELECTED_CHILDREN_CHANGED,
376  ax::mojom::Event::kSelectedChildrenChanged);
377 }

◆ TEST() [28/165]

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

Definition at line 389 of file accessibility_bridge_windows_unittests.cc.

389  {
390  ExpectWinEventFromAXEvent(
391  1, ui::AXEventGenerator::Event::WIN_IACCESSIBLE_STATE_CHANGED,
392  ax::mojom::Event::kStateChanged);
393 }

◆ TEST() [29/165]

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

Definition at line 379 of file accessibility_bridge_windows_unittests.cc.

379  {
380  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::SUBTREE_CREATED,
381  ax::mojom::Event::kShow);
382 }

◆ TEST() [30/165]

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

Definition at line 384 of file accessibility_bridge_windows_unittests.cc.

384  {
385  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::VALUE_CHANGED,
386  ax::mojom::Event::kValueChanged);
387 }

◆ TEST() [31/165]

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

Definition at line 362 of file accessibility_bridge_windows_unittests.cc.

362  {
363  ExpectWinEventFromAXEvent(
364  1, ui::AXEventGenerator::Event::SCROLL_VERTICAL_POSITION_CHANGED,
365  ax::mojom::Event::kScrollPositionChanged);
366 }

◆ TEST() [32/165]

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

Definition at line 395 of file accessibility_bridge_windows_unittests.cc.

395  {
396  ExpectWinEventFromAXEventOnFocusNode(
397  1, ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED,
398  ax::mojom::Event::kDocumentSelectionChanged, 2);
399 }

◆ 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::@98::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 795 of file flutter_windows_view_unittests.cc.

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

◆ TEST() [62/165]

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

Definition at line 365 of file flutter_windows_view_unittests.cc.

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

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

References node_delegate.

◆ TEST() [64/165]

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

Definition at line 1153 of file flutter_windows_view_unittests.cc.

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

◆ TEST() [65/165]

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

Definition at line 1553 of file flutter_windows_view_unittests.cc.

1553  {
1554  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1555  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1556  auto egl_manager = std::make_unique<egl::MockManager>();
1557  egl::MockContext render_context;
1558  auto surface = std::make_unique<egl::MockWindowSurface>();
1559  auto surface_ptr = surface.get();
1560 
1561  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1562  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1563  .WillOnce(Return(true));
1564 
1565  EXPECT_CALL(*egl_manager.get(), render_context)
1566  .WillOnce(Return(&render_context));
1567  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1568 
1569  InSequence s;
1570  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1571  .WillOnce(Return(std::move(surface)));
1572  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1573  .WillOnce([](fml::closure callback) {
1574  callback();
1575  return true;
1576  });
1577  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1578  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1579  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1580  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1581  .WillOnce([](fml::closure callback) {
1582  callback();
1583  return true;
1584  });
1585  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1586 
1587  EngineModifier modifier{engine.get()};
1588  modifier.SetEGLManager(std::move(egl_manager));
1589 
1590  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1591  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1592 }

References callback.

◆ TEST() [66/165]

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

Definition at line 1482 of file flutter_windows_view_unittests.cc.

1482  {
1483  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1484  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1485  auto egl_manager = std::make_unique<egl::MockManager>();
1486  egl::MockContext render_context;
1487  auto surface = std::make_unique<egl::MockWindowSurface>();
1488  auto surface_ptr = surface.get();
1489 
1490  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1491  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1492 
1493  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1494  .WillOnce(Return(true));
1495 
1496  EXPECT_CALL(*egl_manager.get(), render_context)
1497  .WillOnce(Return(&render_context));
1498  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1499 
1500  InSequence s;
1501  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1502  .WillOnce(Return(std::move(surface)));
1503  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1504  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1505  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1506 
1507  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1508 
1509  EngineModifier modifier{engine.get()};
1510  modifier.SetEGLManager(std::move(egl_manager));
1511 
1512  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1513  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1514 }

◆ TEST() [67/165]

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

Definition at line 343 of file flutter_windows_view_unittests.cc.

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

◆ TEST() [68/165]

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

Definition at line 1596 of file flutter_windows_view_unittests.cc.

1596  {
1597  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1598  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1599  auto egl_manager = std::make_unique<egl::MockManager>();
1600  egl::MockContext render_context;
1601  auto surface = std::make_unique<egl::MockWindowSurface>();
1602  auto surface_ptr = surface.get();
1603 
1604  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1605 
1606  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1607  .WillOnce(Return(false));
1608 
1609  EXPECT_CALL(*egl_manager.get(), render_context)
1610  .WillOnce(Return(&render_context));
1611  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1612 
1613  InSequence s;
1614  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1615  .WillOnce(Return(std::move(surface)));
1616  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1617  .WillOnce([](fml::closure callback) {
1618  callback();
1619  return true;
1620  });
1621 
1622  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1623  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1624  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1625 
1626  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1627  .WillOnce([](fml::closure callback) {
1628  callback();
1629  return true;
1630  });
1631  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1632 
1633  EngineModifier modifier{engine.get()};
1634  modifier.SetEGLManager(std::move(egl_manager));
1635 
1636  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1637  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1638 }

References callback.

◆ TEST() [69/165]

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

Definition at line 1518 of file flutter_windows_view_unittests.cc.

1518  {
1519  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1520  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1521  auto egl_manager = std::make_unique<egl::MockManager>();
1522  egl::MockContext render_context;
1523  auto surface = std::make_unique<egl::MockWindowSurface>();
1524  auto surface_ptr = surface.get();
1525 
1526  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1527  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1528  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1529  .WillOnce(Return(false));
1530 
1531  EXPECT_CALL(*egl_manager.get(), render_context)
1532  .WillOnce(Return(&render_context));
1533  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1534 
1535  InSequence s;
1536  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1537  .WillOnce(Return(std::move(surface)));
1538  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1539  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1540  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1541 
1542  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1543 
1544  EngineModifier modifier{engine.get()};
1545  modifier.SetEGLManager(std::move(egl_manager));
1546 
1547  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1548  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1549 }

◆ TEST() [70/165]

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

Definition at line 1704 of file flutter_windows_view_unittests.cc.

1704  {
1705  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1706  auto window_binding_handler =
1707  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1708  EXPECT_CALL(*window_binding_handler, Focus()).WillOnce(Return(true));
1709  std::unique_ptr<FlutterWindowsView> view =
1710  engine->CreateView(std::move(window_binding_handler));
1711  EXPECT_TRUE(view->Focus());
1712 }

◆ TEST() [71/165]

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

Definition at line 314 of file flutter_windows_view_unittests.cc.

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

References callback, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST() [72/165]

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

Definition at line 296 of file flutter_windows_view_unittests.cc.

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

References kScanCodeKeyA, and kVirtualKeyA.

◆ TEST() [73/165]

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

Definition at line 667 of file flutter_windows_view_unittests.cc.

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

◆ TEST() [74/165]

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

Definition at line 1714 of file flutter_windows_view_unittests.cc.

1714  {
1715  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1716  auto window_binding_handler =
1717  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1718  std::unique_ptr<FlutterWindowsView> view =
1719  engine->CreateView(std::move(window_binding_handler));
1720 
1721  EngineModifier modifier(engine.get());
1722  bool received_focus_event = false;
1723  modifier.embedder_api().SendViewFocusEvent = MOCK_ENGINE_PROC(
1724  SendViewFocusEvent, [&](FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
1725  FlutterViewFocusEvent const* event) {
1726  EXPECT_EQ(event->state, FlutterViewFocusState::kFocused);
1727  EXPECT_EQ(event->direction, FlutterViewFocusDirection::kUndefined);
1728  EXPECT_EQ(event->view_id, view->view_id());
1729  EXPECT_EQ(event->struct_size, sizeof(FlutterViewFocusEvent));
1730  received_focus_event = true;
1731  return kSuccess;
1732  });
1733  view->OnFocus(FlutterViewFocusState::kFocused,
1734  FlutterViewFocusDirection::kUndefined);
1735  EXPECT_TRUE(received_focus_event);
1736 }

◆ TEST() [75/165]

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

Definition at line 246 of file flutter_windows_view_unittests.cc.

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

References callback.

◆ TEST() [76/165]

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

Definition at line 1753 of file flutter_windows_view_unittests.cc.

1753  {
1754  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1755  EngineModifier modifier(engine.get());
1756 
1757  auto window_binding_handler =
1758  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1759  EXPECT_CALL(*window_binding_handler, GetDisplayId)
1760  .WillOnce(testing::Return(12));
1761  FlutterWindowsView view{kImplicitViewId, engine.get(),
1762  std::move(window_binding_handler)};
1763 
1764  bool received_metrics = false;
1765  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1766  SendWindowMetricsEvent,
1767  ([&received_metrics](auto engine,
1768  const FlutterWindowMetricsEvent* event) {
1769  received_metrics = true;
1770  EXPECT_EQ(event->display_id, 12);
1771  return kSuccess;
1772  }));
1773  view.OnWindowSizeChanged(100, 100);
1774  EXPECT_TRUE(received_metrics);
1775 }
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 
150  // Enable semantics to instantiate accessibility bridge.
151  view->OnUpdateSemanticsEnabled(true);
152 
153  auto bridge = view->accessibility_bridge().lock();
154  ASSERT_TRUE(bridge);
155 
156  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
157  root.id = 0;
158  root.label = "root";
159  root.hint = "";
160  root.value = "";
161  root.increased_value = "";
162  root.decreased_value = "";
163  root.child_count = 0;
164  root.custom_accessibility_actions_count = 0;
165  auto flags = FlutterSemanticsFlags{
166  .is_expanded = FlutterTristate::kFlutterTristateTrue,
167  };
168  root.flags2 = &flags;
169 
170  bridge->AddFlutterSemanticsNodeUpdate(root);
171 
172  bridge->CommitUpdates();
173 
174  {
175  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
176  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kExpanded));
177 
178  // Get the IAccessible for the root node.
179  IAccessible* native_view = root_node->GetNativeViewAccessible();
180  ASSERT_TRUE(native_view != nullptr);
181 
182  // Look up against the node itself (not one of its children).
183  VARIANT varchild = {};
184  varchild.vt = VT_I4;
185 
186  // Verify the submenu is expanded.
187  varchild.lVal = CHILDID_SELF;
188  VARIANT native_state = {};
189  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
190  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_EXPANDED);
191 
192  // Perform similar tests for UIA value;
193  IRawElementProviderSimple* uia_node;
194  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
195  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
196  UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
197  EXPECT_EQ(native_state.lVal, ExpandCollapseState_Expanded);
198 
199  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
200  UIA_AriaPropertiesPropertyId, &native_state)));
201  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=true"), nullptr);
202  }
203 
204  // Test collapsed too.
205  auto updated_flags = FlutterSemanticsFlags{
206  .is_expanded = FlutterTristate::kFlutterTristateFalse,
207  };
208  root.flags2 = &updated_flags;
209 
210  bridge->AddFlutterSemanticsNodeUpdate(root);
211  bridge->CommitUpdates();
212 
213  {
214  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
215  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kCollapsed));
216 
217  // Get the IAccessible for the root node.
218  IAccessible* native_view = root_node->GetNativeViewAccessible();
219  ASSERT_TRUE(native_view != nullptr);
220 
221  // Look up against the node itself (not one of its children).
222  VARIANT varchild = {};
223  varchild.vt = VT_I4;
224 
225  // Verify the submenu is collapsed.
226  varchild.lVal = CHILDID_SELF;
227  VARIANT native_state = {};
228  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
229  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_COLLAPSED);
230 
231  // Perform similar tests for UIA value;
232  IRawElementProviderSimple* uia_node;
233  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
234  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
235  UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
236  EXPECT_EQ(native_state.lVal, ExpandCollapseState_Collapsed);
237 
238  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
239  UIA_AriaPropertiesPropertyId, &native_state)));
240  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=false"), nullptr);
241  }
242 }

◆ TEST() [78/165]

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

Definition at line 1301 of file flutter_windows_view_unittests.cc.

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

◆ TEST() [79/165]

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

Definition at line 963 of file flutter_windows_view_unittests.cc.

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

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

◆ TEST() [81/165]

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

Definition at line 1643 of file flutter_windows_view_unittests.cc.

1643  {
1644  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1645  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1646  auto egl_manager = std::make_unique<egl::MockManager>();
1647  egl::MockContext render_context;
1648  auto surface = std::make_unique<egl::MockWindowSurface>();
1649  auto surface_ptr = surface.get();
1650 
1651  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1652 
1653  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1654  .WillRepeatedly([](fml::closure callback) {
1655  callback();
1656  return true;
1657  });
1658 
1659  EXPECT_CALL(*egl_manager.get(), render_context)
1660  .WillRepeatedly(Return(&render_context));
1661 
1662  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
1663  EXPECT_CALL(*surface_ptr, MakeCurrent).WillRepeatedly(Return(true));
1664  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1665  EXPECT_CALL(render_context, ClearCurrent).WillRepeatedly(Return(true));
1666 
1667  InSequence s;
1668 
1669  // Mock render surface initialization.
1670  std::unique_ptr<FlutterWindowsView> view;
1671  {
1672  EXPECT_CALL(*egl_manager, CreateWindowSurface)
1673  .WillOnce(Return(std::move(surface)));
1674  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1675  .WillOnce(Return(true));
1676  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
1677 
1678  EngineModifier engine_modifier{engine.get()};
1679  engine_modifier.SetEGLManager(std::move(egl_manager));
1680 
1681  view = engine->CreateView(
1682  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1683  }
1684 
1685  // Disabling DWM composition should enable vsync blocking on the surface.
1686  {
1687  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1688  .WillOnce(Return(false));
1689  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1690 
1691  engine->OnDwmCompositionChanged();
1692  }
1693 
1694  // Enabling DWM composition should disable vsync blocking on the surface.
1695  {
1696  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1697  .WillOnce(Return(true));
1698  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1699 
1700  engine->OnDwmCompositionChanged();
1701  }
1702 }

References callback.

◆ TEST() [82/165]

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

Definition at line 1738 of file flutter_windows_view_unittests.cc.

1738  {
1739  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1740  EngineModifier modifier(engine.get());
1741 
1742  auto window_binding_handler =
1743  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1744  EXPECT_CALL(*window_binding_handler, GetDisplayId)
1745  .WillOnce(testing::Return(12));
1746  FlutterWindowsView view{kImplicitViewId, engine.get(),
1747  std::move(window_binding_handler)};
1748 
1749  FlutterWindowMetricsEvent event = view.CreateWindowMetricsEvent();
1750  EXPECT_EQ(event.display_id, 12);
1751 }

References flutter::kImplicitViewId.

◆ TEST() [83/165]

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

Definition at line 1128 of file flutter_windows_view_unittests.cc.

1128  {
1129  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1130  EngineModifier modifier(engine.get());
1131 
1132  FlutterWindowsView view{kImplicitViewId, engine.get(),
1133  std::make_unique<flutter::FlutterWindow>(
1134  100, 100, engine->display_manager())};
1135 
1136  bool schedule_frame_called = false;
1137  modifier.embedder_api().ScheduleFrame =
1138  MOCK_ENGINE_PROC(ScheduleFrame, ([&schedule_frame_called](auto engine) {
1139  schedule_frame_called = true;
1140  return kSuccess;
1141  }));
1142 
1143  view.OnWindowRepaint();
1144  EXPECT_TRUE(schedule_frame_called);
1145 }

References flutter::kImplicitViewId.

◆ TEST() [84/165]

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

Definition at line 1066 of file flutter_windows_view_unittests.cc.

1066  {
1067  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1068 
1069  EngineModifier engine_modifier(engine.get());
1070  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1071  PostRenderThreadTask,
1072  ([](auto engine, VoidCallback callback, void* user_data) {
1073  callback(user_data);
1074  return kSuccess;
1075  }));
1076 
1077  auto egl_manager = std::make_unique<egl::MockManager>();
1078  auto surface = std::make_unique<egl::MockWindowSurface>();
1079 
1080  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1081  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(false));
1082  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(false));
1083 
1084  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1085  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1086 
1087  ViewModifier view_modifier{view.get()};
1088  engine_modifier.SetEGLManager(std::move(egl_manager));
1089  view_modifier.SetSurface(std::move(surface));
1090 
1091  auto metrics_sent = false;
1092  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1093  SendWindowMetricsEvent,
1094  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1095  metrics_sent = true;
1096  return kSuccess;
1097  }));
1098 
1099  view->OnWindowSizeChanged(500, 500);
1100 }

References callback, and user_data.

◆ TEST() [85/165]

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

Definition at line 1027 of file flutter_windows_view_unittests.cc.

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

References callback, and user_data.

◆ TEST() [86/165]

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

Definition at line 892 of file flutter_windows_view_unittests.cc.

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

References callback, and user_data.

◆ TEST() [87/165]

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

Definition at line 1104 of file flutter_windows_view_unittests.cc.

1104  {
1105  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1106  EngineModifier modifier(engine.get());
1107 
1108  auto egl_manager = std::make_unique<egl::MockManager>();
1109 
1110  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1111 
1112  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1113  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1114 
1115  modifier.SetEGLManager(std::move(egl_manager));
1116 
1117  auto metrics_sent = false;
1118  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1119  SendWindowMetricsEvent,
1120  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1121  metrics_sent = true;
1122  return kSuccess;
1123  }));
1124 
1125  view->OnWindowSizeChanged(500, 500);
1126 }

◆ 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::@98::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/187]

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

Definition at line 108 of file accessibility_plugin_unittests.cc.

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

◆ TEST_F() [2/187]

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

Definition at line 117 of file accessibility_plugin_unittests.cc.

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

◆ TEST_F() [3/187]

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

Definition at line 126 of file accessibility_plugin_unittests.cc.

126  {
127  // Should not be called with invalid viewId type
128  EXPECT_CALL(*view(), AnnounceAlert(_)).Times(0);
129 
130  SendAnnounceMessage("Hello", EncodableValue{"invalid"});
131 }

◆ TEST_F() [4/187]

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

Definition at line 132 of file accessibility_plugin_unittests.cc.

132  {
133  // Should not be called when message is missing
134  EXPECT_CALL(*view(), AnnounceAlert(_)).Times(0);
135 
136  EncodableMap data;
137  data[EncodableValue{"viewId"}] = EncodableValue{static_cast<int32_t>(0)};
138 
139  EncodableMap msg;
140  msg[EncodableValue{"type"}] = EncodableValue{"announce"};
141  msg[EncodableValue{"data"}] = EncodableValue{data};
142 
143  auto encoded =
144  StandardMessageCodec::GetInstance().EncodeMessage(EncodableValue{msg});
145 
146  messenger()->SimulateEngineMessage(
147  kAccessibilityChannelName, encoded->data(), encoded->size(),
148  [](const uint8_t* reply, size_t reply_size) {});
149 }
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/187]

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

Definition at line 98 of file accessibility_plugin_unittests.cc.

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

References flutter::AccessibilityPlugin::Announce().

◆ TEST_F() [6/187]

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

Definition at line 139 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [7/187]

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

Definition at line 153 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [8/187]

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

Definition at line 167 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [9/187]

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

Definition at line 180 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [10/187]

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

Definition at line 244 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [11/187]

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

Definition at line 204 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [12/187]

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

Definition at line 229 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [13/187]

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

Definition at line 266 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [14/187]

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

Definition at line 70 of file compositor_software_unittests.cc.

70  {
71  CompositorSoftware compositor;
72 
73  FlutterBackingStoreConfig config = {};
74  FlutterBackingStore backing_store = {};
75 
76  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
77  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
78 }

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

◆ TEST_F() [15/187]

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

Definition at line 80 of file compositor_software_unittests.cc.

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

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

◆ TEST_F() [16/187]

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

Definition at line 101 of file compositor_software_unittests.cc.

101  {
102  UseEngineWithView();
103 
104  CompositorSoftware compositor;
105 
106  EXPECT_CALL(*view(), ClearSoftwareBitmap).WillOnce(Return(true));
107  EXPECT_TRUE(compositor.Present(view(), nullptr, 0));
108 }

References flutter::CompositorSoftware::Present().

◆ TEST_F() [17/187]

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

Definition at line 117 of file compositor_software_unittests.cc.

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

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

◆ TEST_F() [18/187]

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

Definition at line 167 of file compositor_software_unittests.cc.

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

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

◆ TEST_F() [19/187]

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

Definition at line 100 of file cursor_handler_unittests.cc.

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

References kActivateSystemCursorMethod.

◆ TEST_F() [20/187]

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

Definition at line 127 of file cursor_handler_unittests.cc.

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

References kCreateCustomCursorMethod.

◆ TEST_F() [21/187]

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

Definition at line 229 of file cursor_handler_unittests.cc.

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

References kCreateCustomCursorMethod, and kDeleteCustomCursorMethod.

◆ TEST_F() [22/187]

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

Definition at line 267 of file cursor_handler_unittests.cc.

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

References kDeleteCustomCursorMethod.

◆ TEST_F() [23/187]

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

Definition at line 158 of file cursor_handler_unittests.cc.

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

References kCreateCustomCursorMethod, and kSetCustomCursorMethod.

◆ TEST_F() [24/187]

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

Definition at line 199 of file cursor_handler_unittests.cc.

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

References kSetCustomCursorMethod.

◆ TEST_F() [25/187]

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/187]

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/187]

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

Definition at line 787 of file flutter_windows_engine_unittests.cc.

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

References flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [28/187]

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

Definition at line 825 of file flutter_windows_engine_unittests.cc.

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

References flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [29/187]

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

Definition at line 849 of file flutter_windows_engine_unittests.cc.

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

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

◆ TEST_F() [30/187]

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/187]

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

Definition at line 1412 of file flutter_windows_engine_unittests.cc.

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

References flutter::FlutterEngine::Run().

◆ TEST_F() [32/187]

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

Definition at line 1118 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [33/187]

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

Definition at line 1362 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [34/187]

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/187]

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/187]

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

Definition at line 1098 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [37/187]

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

Definition at line 1261 of file flutter_windows_engine_unittests.cc.

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

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

◆ TEST_F() [38/187]

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

Definition at line 1191 of file flutter_windows_engine_unittests.cc.

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

References flutter::kHidden.

◆ TEST_F() [39/187]

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/187]

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

Definition at line 1219 of file flutter_windows_engine_unittests.cc.

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

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

◆ TEST_F() [41/187]

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

Definition at line 1079 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [42/187]

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

Definition at line 1313 of file flutter_windows_engine_unittests.cc.

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

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

◆ TEST_F() [43/187]

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

Definition at line 1137 of file flutter_windows_engine_unittests.cc.

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

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

◆ TEST_F() [44/187]

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

Definition at line 1460 of file flutter_windows_engine_unittests.cc.

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

References RunOnPlatformThread.

◆ TEST_F() [45/187]

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

Definition at line 1480 of file flutter_windows_engine_unittests.cc.

1480  {
1481  FlutterWindowsEngineBuilder builder{GetContext()};
1482  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1483  auto window_binding_handler =
1484  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1485  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1486 
1487  EngineModifier modifier(engine.get());
1488  modifier.SetImplicitView(&view);
1489 
1490  FlutterViewFocusChangeRequest request;
1491  request.view_id = kImplicitViewId;
1492 
1493  EXPECT_CALL(view, Focus()).WillOnce(Return(true));
1494  modifier.OnViewFocusChangeRequest(&request);
1495 }

References flutter::kImplicitViewId.

◆ TEST_F() [46/187]

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/187]

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/187]

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/187]

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

Definition at line 1387 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [50/187]

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

Definition at line 1442 of file flutter_windows_engine_unittests.cc.

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

References flutter::FlutterEngine::Run().

◆ TEST_F() [51/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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

Definition at line 904 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [63/187]

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

Definition at line 940 of file flutter_windows_engine_unittests.cc.

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

References message.

◆ TEST_F() [64/187]

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

Definition at line 1046 of file flutter_windows_engine_unittests.cc.

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

◆ TEST_F() [65/187]

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

Definition at line 987 of file flutter_windows_engine_unittests.cc.

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

References message, and user_data.

◆ TEST_F() [66/187]

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/187]

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

Definition at line 1497 of file flutter_windows_engine_unittests.cc.

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

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

◆ TEST_F() [68/187]

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

Definition at line 316 of file flutter_window_unittests.cc.

316  {
317  MockFlutterWindow win32window;
318 
319  EXPECT_EQ(win32window.GetNativeViewAccessible(), nullptr);
320 }

◆ TEST_F() [69/187]

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

Definition at line 324 of file flutter_window_unittests.cc.

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

References message.

◆ TEST_F() [70/187]

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

Definition at line 394 of file flutter_window_unittests.cc.

394  {
395  MockFlutterWindow win32window;
396  EXPECT_CALL(win32window, GetWindowHandle)
397  .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
398  EXPECT_CALL(win32window, OnWindowStateEvent)
399  .WillRepeatedly([&](WindowStateEvent event) {
400  win32window.FlutterWindow::OnWindowStateEvent(event);
401  });
402  EXPECT_CALL(win32window, OnResize).Times(1);
403 
404  // Restore
405  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
406 
407  // Focus
408  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
409 
410  MockWindowBindingHandlerDelegate delegate;
411  bool focused = false;
412  bool restored = false;
413  EXPECT_CALL(delegate, OnWindowStateEvent)
414  .WillRepeatedly([&](HWND hwnd, WindowStateEvent event) {
415  if (event == WindowStateEvent::kFocus) {
416  focused = true;
417  } else if (event == WindowStateEvent::kShow) {
418  restored = true;
419  }
420  });
421 
422  EXPECT_CALL(delegate, OnFocus(Eq(FlutterViewFocusState::kFocused),
423  Eq(FlutterViewFocusDirection::kUndefined)))
424  .Times(1);
425  win32window.SetView(&delegate);
426  EXPECT_TRUE(focused);
427  EXPECT_TRUE(restored);
428 }
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/187]

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

Definition at line 118 of file flutter_window_unittests.cc.

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

◆ TEST_F() [72/187]

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

Definition at line 356 of file flutter_window_unittests.cc.

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

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

◆ TEST_F() [73/187]

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

Definition at line 125 of file flutter_window_unittests.cc.

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

References flutter::FlutterWindow::OnBitmapSurfaceUpdated().

◆ TEST_F() [74/187]

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

Definition at line 157 of file flutter_window_unittests.cc.

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

◆ TEST_F() [75/187]

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

Definition at line 144 of file flutter_window_unittests.cc.

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

◆ TEST_F() [76/187]

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

Definition at line 168 of file flutter_window_unittests.cc.

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

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

◆ TEST_F() [77/187]

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

Definition at line 271 of file flutter_window_unittests.cc.

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

◆ TEST_F() [78/187]

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

Definition at line 302 of file flutter_window_unittests.cc.

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

◆ TEST_F() [79/187]

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

Definition at line 291 of file flutter_window_unittests.cc.

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

◆ TEST_F() [80/187]

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

Definition at line 1274 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [81/187]

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

Definition at line 1361 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [82/187]

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

Definition at line 837 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [83/187]

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

Definition at line 870 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [84/187]

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

Definition at line 631 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [85/187]

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

Definition at line 662 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [86/187]

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

Definition at line 1184 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [87/187]

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

Definition at line 1126 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [88/187]

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

Definition at line 771 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [89/187]

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

Definition at line 804 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [90/187]

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

Definition at line 1464 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [91/187]

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

Definition at line 1608 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [92/187]

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

Definition at line 1677 of file keyboard_unittests.cc.

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

References callback, EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [93/187]

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

Definition at line 1527 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [94/187]

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

Definition at line 1241 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [95/187]

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

Definition at line 2500 of file keyboard_unittests.cc.

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

◆ TEST_F() [96/187]

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

Definition at line 1032 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [97/187]

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

Definition at line 2026 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [98/187]

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

Definition at line 568 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [99/187]

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

Definition at line 599 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [100/187]

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

Definition at line 905 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [101/187]

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

Definition at line 937 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [102/187]

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

Definition at line 1761 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [103/187]

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

Definition at line 971 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [104/187]

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

Definition at line 1000 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [105/187]

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

Definition at line 1066 of file keyboard_unittests.cc.

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

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

◆ TEST_F() [106/187]

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

Definition at line 693 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [107/187]

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

Definition at line 738 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftRight.

◆ TEST_F() [108/187]

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

Definition at line 2093 of file keyboard_unittests.cc.

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

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

◆ TEST_F() [109/187]

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

Definition at line 2156 of file keyboard_unittests.cc.

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

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

◆ TEST_F() [110/187]

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

Definition at line 1798 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [111/187]

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

Definition at line 2232 of file keyboard_unittests.cc.

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

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

◆ TEST_F() [112/187]

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

Definition at line 2054 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [113/187]

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

Definition at line 2300 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [114/187]

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

Definition at line 2490 of file keyboard_unittests.cc.

2490  {
2491  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), false);
2492 }
flutter::testing::VietnameseTelexAddDiacriticWithSlowResponse
void VietnameseTelexAddDiacriticWithSlowResponse(WindowsTestContext &context, bool backspace_response)
Definition: keyboard_unittests.cc:2383

References VietnameseTelexAddDiacriticWithSlowResponse().

◆ TEST_F() [115/187]

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

Definition at line 2494 of file keyboard_unittests.cc.

2494  {
2495  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), true);
2496 }

References VietnameseTelexAddDiacriticWithSlowResponse().

◆ TEST_F() [116/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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/187]

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

Definition at line 240 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [135/187]

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

Definition at line 219 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [136/187]

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

Definition at line 554 of file text_input_plugin_unittest.cc.

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

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

Definition at line 724 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [138/187]

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

Definition at line 430 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [139/187]

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

Definition at line 462 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [140/187]

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

Definition at line 687 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [141/187]

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

Definition at line 495 of file text_input_plugin_unittest.cc.

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

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

Definition at line 194 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [143/187]

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

Definition at line 614 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [144/187]

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

Definition at line 268 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [145/187]

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

Definition at line 325 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [146/187]

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

Definition at line 383 of file text_input_plugin_unittest.cc.

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

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

◆ TEST_F() [147/187]

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

Definition at line 173 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 150 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 196 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 274 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 243 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 219 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 319 of file window_manager_unittests.cc.

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

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/187]

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

Definition at line 304 of file window_manager_unittests.cc.

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

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

◆ TEST_F() [155/187]

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

Definition at line 85 of file window_manager_unittests.cc.

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

References InternalFlutterWindows_WindowManager_CreateRegularWindow().

◆ TEST_F() [156/187]

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

Definition at line 353 of file window_manager_unittests.cc.

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

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() [157/187]

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

Definition at line 94 of file window_manager_unittests.cc.

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

References InternalFlutterWindows_WindowManager_CreateRegularWindow(), and InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle().

◆ TEST_F() [158/187]

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

Definition at line 106 of file window_manager_unittests.cc.

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

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

◆ TEST_F() [159/187]

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

Definition at line 125 of file window_manager_unittests.cc.

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

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() [160/187]

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

Definition at line 68 of file window_manager_unittests.cc.

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

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

◆ TEST_F() [161/187]

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() [162/187]

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() [163/187]

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() [164/187]

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() [165/187]

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() [166/187]

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() [167/187]

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() [168/187]

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() [169/187]

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() [170/187]

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() [171/187]

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() [172/187]

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() [173/187]

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() [174/187]

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() [175/187]

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

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() [177/187]

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() [178/187]

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() [179/187]

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() [180/187]

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() [181/187]

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() [182/187]

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() [183/187]

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() [184/187]

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() [185/187]

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() [186/187]

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

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 2383 of file keyboard_unittests.cc.

2384  {
2385  // In this test, the user presses the following keys:
2386  //
2387  // Key Current text
2388  // ===========================
2389  // A a
2390  // F à
2391  //
2392  // And the Backspace down event is responded slowly with `backspace_response`.
2393 
2394  KeyboardTester tester{context};
2395  tester.Responding(false);
2396 
2397  // US Keyboard layout
2398 
2399  // Press A
2400  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2401  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2402  kWmResultZero),
2403  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2404  kWmResultZero)});
2405 
2406  EXPECT_EQ(tester.key_calls.size(), 2);
2407  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2408  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2409  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2410  tester.clear_key_calls();
2411  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2412 
2413  // Release A
2414  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2415  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2416  kWmResultZero)});
2417 
2418  EXPECT_EQ(tester.key_calls.size(), 1);
2419  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2420  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2421  tester.clear_key_calls();
2422  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2423 
2424  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2425  tester.LateResponding(
2426  [&recorded_callbacks](
2427  const FlutterKeyEvent* event,
2428  MockKeyResponseController::ResponseCallback callback) {
2429  recorded_callbacks.push_back(callback);
2430  });
2431 
2432  // Press F, which is translated to:
2433  //
2434  // Backspace down, char & up, VK_PACKET('à').
2435  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2436  WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2437  kWmResultZero),
2438  WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2439  kWmResultZero),
2440  WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2441  kWmResultZero),
2442  WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2443  WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2444  WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2445 
2446  // The Backspace event has not responded yet, therefore the char message must
2447  // hold. This is because when the framework is handling the Backspace event,
2448  // it will send a setEditingState message that updates the text state that has
2449  // the last character deleted (denoted by `string1`). Processing the char
2450  // message before then will cause the final text to set to `string1`.
2451  EXPECT_EQ(tester.key_calls.size(), 1);
2452  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2453  kPhysicalBackspace, kLogicalBackspace, "",
2454  kNotSynthesized);
2455  tester.clear_key_calls();
2456  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2457 
2458  EXPECT_EQ(recorded_callbacks.size(), 1);
2459  recorded_callbacks[0](backspace_response);
2460 
2461  EXPECT_EQ(tester.key_calls.size(), 1);
2462  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2463  kPhysicalBackspace, kLogicalBackspace, "",
2464  kNotSynthesized);
2465  tester.clear_key_calls();
2466  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(),
2467  backspace_response ? 0 : 2);
2468 
2469  recorded_callbacks[1](false);
2470  EXPECT_EQ(tester.key_calls.size(), 1);
2471  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"à");
2472  tester.clear_key_calls();
2473  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2474 
2475  tester.Responding(false);
2476 
2477  // Release F
2478  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2479  WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2480  /* overwrite_prev_state_0 */ true}
2481  .Build(kWmResultZero)});
2482 
2483  EXPECT_EQ(tester.key_calls.size(), 1);
2484  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2485  kNotSynthesized);
2486  tester.clear_key_calls();
2487  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2488 }

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