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

Classes

class  CursorHandlerTest
 
class  FlutterWindowsEngineTest
 
class  MockFlutterWindowsView
 
class  MockIDirectManipulationContent
 
class  MockIDirectManipulationViewport
 
class  MockWindowsLifecycleManager
 
class  PlatformHandlerTest
 
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 (CompositorOpenGLTest, CreateBackingStore)
 
 TEST_F (CompositorOpenGLTest, InitializationFailure)
 
 TEST_F (CompositorOpenGLTest, Present)
 
 TEST_F (CompositorOpenGLTest, PresentEmpty)
 
 TEST_F (CompositorOpenGLTest, HeadlessPresentIgnored)
 
 TEST_F (CompositorOpenGLTest, UnknownViewIgnored)
 
 TEST_F (CompositorOpenGLTest, NoSurfaceIgnored)
 
 TEST_F (CompositorSoftwareTest, CreateBackingStore)
 
 TEST_F (CompositorSoftwareTest, Present)
 
 TEST_F (CompositorSoftwareTest, PresentEmpty)
 
 TEST_F (CompositorSoftwareTest, UnknownViewIgnored)
 
 TEST_F (CompositorSoftwareTest, HeadlessPresentIgnored)
 
 TEST_F (CursorHandlerTest, ActivateSystemCursor)
 
 TEST_F (CursorHandlerTest, ActivateSystemCursorRequiresView)
 
 TEST_F (CursorHandlerTest, CreateCustomCursor)
 
 TEST_F (CursorHandlerTest, SetCustomCursor)
 
 TEST_F (CursorHandlerTest, SetCustomCursorRequiresView)
 
 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 (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 (FlutterWindowTest, UpdateCursor)
 
 TEST_F (FlutterWindowsEngineTest, RunHeadless)
 
 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, AppStartsInResumedState)
 
 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 (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, GetViewId)
 
 TEST_F (WindowsTest, GetGraphicsAdapter)
 
 TEST_F (WindowsTest, PluginRegistrarGetImplicitView)
 
 TEST_F (WindowsTest, PluginRegistrarGetView)
 
 TEST_F (WindowsTest, PluginRegistrarGetViewHeadless)
 
 TEST_F (WindowsTest, SurfaceOptional)
 
 TEST_F (WindowsTest, Lifecycle)
 
 TEST (FlutterWindowsViewTest, SubMenuExpandedState)
 
 TEST (FlutterWindowsViewTest, Shutdown)
 
 TEST (FlutterWindowsViewTest, KeySequence)
 
 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 (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, 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, GetClipboardDataRequiresView)
 
 TEST_F (PlatformHandlerTest, GetClipboardDataReportsOpenFailure)
 
 TEST_F (PlatformHandlerTest, GetClipboardDataReportsGetDataFailure)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStrings)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsReturnsFalse)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsRejectsUnknownContentType)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsRequiresView)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsIgnoresPermissionErrors)
 
 TEST_F (PlatformHandlerTest, ClipboardHasStringsReportsErrors)
 
 TEST_F (PlatformHandlerTest, ClipboardSetData)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataTextMustBeString)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataUnknownType)
 
 TEST_F (PlatformHandlerTest, ClipboardSetDataRequiresView)
 
 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_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, TextEditingWorksWithDeltaModel)
 
 TEST_F (TextInputPluginTest, CompositionCursorPos)
 
 TEST_F (TextInputPluginTest, TransformCursorRect)
 
 TEST_F (TextInputPluginTest, SetMarkedTextRectRequiresView)
 
 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)
 
 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
 

Function Documentation

◆ CreateSemanticsNode()

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

Definition at line 18 of file accessibility_bridge_unittests.cc.

21  {
22  return {
23  .id = id,
24  .flags = static_cast<FlutterSemanticsFlag>(0),
25  .actions = static_cast<FlutterSemanticsAction>(0),
26  .text_selection_base = -1,
27  .text_selection_extent = -1,
28  .label = label,
29  .hint = "",
30  .value = "",
31  .increased_value = "",
32  .decreased_value = "",
33  .child_count = children ? children->size() : 0,
34  .children_in_traversal_order = children ? children->data() : nullptr,
35  .custom_accessibility_actions_count = 0,
36  .tooltip = "",
37  };
38 }

Referenced by TEST().

◆ TEST() [1/158]

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

Definition at line 72 of file accessibility_bridge_unittests.cc.

72  {
73  std::shared_ptr<TestAccessibilityBridge> bridge =
74  std::make_shared<TestAccessibilityBridge>();
75 
76  std::vector<int32_t> children{456, 789};
77  FlutterSemanticsNode2 root = CreateSemanticsNode(123, "root", &children);
78  FlutterSemanticsNode2 child1 = CreateSemanticsNode(456, "child 1");
79  FlutterSemanticsNode2 child2 = CreateSemanticsNode(789, "child 2");
80 
81  bridge->AddFlutterSemanticsNodeUpdate(root);
82  bridge->AddFlutterSemanticsNodeUpdate(child1);
83  bridge->AddFlutterSemanticsNodeUpdate(child2);
84  bridge->CommitUpdates();
85 
86  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(123).lock();
87  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(456).lock();
88  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(789).lock();
89  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
90 
91  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 123);
92  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
93 
94  EXPECT_EQ(root_node->GetChildCount(), 2);
95  EXPECT_EQ(root_node->GetData().child_ids[0], 456);
96  EXPECT_EQ(root_node->GetData().child_ids[1], 789);
97  EXPECT_EQ(root_node->GetName(), "root");
98 
99  EXPECT_EQ(child1_node->GetChildCount(), 0);
100  EXPECT_EQ(child1_node->GetName(), "child 1");
101 
102  EXPECT_EQ(child2_node->GetChildCount(), 0);
103  EXPECT_EQ(child2_node->GetName(), "child 2");
104 
105  ASSERT_FALSE(fake_delegate);
106 }

References CreateSemanticsNode().

◆ TEST() [2/158]

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

Definition at line 109 of file accessibility_bridge_unittests.cc.

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

References CreateSemanticsNode().

◆ TEST() [3/158]

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

Definition at line 546 of file accessibility_bridge_unittests.cc.

546  {
547  std::shared_ptr<TestAccessibilityBridge> bridge =
548  std::make_shared<TestAccessibilityBridge>();
549 
550  ui::AXTreeID tree_id = bridge->GetTreeID();
551  ui::AXTreeManager* manager =
552  ui::AXTreeManagerMap::GetInstance().GetManager(tree_id);
553  ASSERT_EQ(manager, static_cast<ui::AXTreeManager*>(bridge.get()));
554 }

◆ TEST() [4/158]

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

Definition at line 40 of file accessibility_bridge_unittests.cc.

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

References CreateSemanticsNode().

◆ TEST() [5/158]

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

Definition at line 160 of file accessibility_bridge_unittests.cc.

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

References CreateSemanticsNode().

◆ TEST() [6/158]

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

Definition at line 208 of file accessibility_bridge_unittests.cc.

208  {
209  std::shared_ptr<TestAccessibilityBridge> bridge =
210  std::make_shared<TestAccessibilityBridge>();
211  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
212  root.flags = static_cast<FlutterSemanticsFlag>(
213  FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField |
214  FlutterSemanticsFlag::kFlutterSemanticsFlagIsFocused);
215  bridge->AddFlutterSemanticsNodeUpdate(root);
216  bridge->CommitUpdates();
217 
218  const ui::AXTreeData& tree = bridge->GetAXTreeData();
219  EXPECT_EQ(tree.sel_anchor_object_id, ui::AXNode::kInvalidAXID);
220  bridge->accessibility_events.clear();
221 
222  // Update the selection.
223  root.text_selection_base = 0;
224  root.text_selection_extent = 5;
225  bridge->AddFlutterSemanticsNodeUpdate(root);
226 
227  bridge->CommitUpdates();
228 
229  EXPECT_EQ(tree.sel_anchor_object_id, 0);
230  EXPECT_EQ(tree.sel_anchor_offset, 0);
231  EXPECT_EQ(tree.sel_focus_object_id, 0);
232  EXPECT_EQ(tree.sel_focus_offset, 5);
233  ASSERT_EQ(bridge->accessibility_events.size(), size_t{2});
234  EXPECT_EQ(bridge->accessibility_events[0],
235  ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED);
236  EXPECT_EQ(bridge->accessibility_events[1],
237  ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED);
238 }

References CreateSemanticsNode().

◆ TEST() [7/158]

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

Definition at line 372 of file accessibility_bridge_unittests.cc.

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

References CreateSemanticsNode().

◆ TEST() [8/158]

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

Definition at line 309 of file accessibility_bridge_unittests.cc.

309  {
310  std::shared_ptr<TestAccessibilityBridge> bridge =
311  std::make_shared<TestAccessibilityBridge>();
312 
313  std::vector<int32_t> root_children{1};
314  std::vector<int32_t> child1_children{2};
315  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &root_children);
316  FlutterSemanticsNode2 child1 =
317  CreateSemanticsNode(1, "child 1", &child1_children);
318  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
319 
320  bridge->AddFlutterSemanticsNodeUpdate(root);
321  bridge->AddFlutterSemanticsNodeUpdate(child1);
322  bridge->AddFlutterSemanticsNodeUpdate(child2);
323  bridge->CommitUpdates();
324  bridge->accessibility_events.clear();
325 
326  // Reparent child2 from child1 to the root.
327  child1.child_count = 0;
328  child1.children_in_traversal_order = nullptr;
329 
330  int32_t new_root_children[] = {1, 2};
331  root.child_count = 2;
332  root.children_in_traversal_order = new_root_children;
333 
334  bridge->AddFlutterSemanticsNodeUpdate(root);
335  bridge->AddFlutterSemanticsNodeUpdate(child1);
336  bridge->AddFlutterSemanticsNodeUpdate(child2);
337  bridge->CommitUpdates();
338 
339  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
340  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
341  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
342 
343  EXPECT_EQ(root_node->GetChildCount(), 2);
344  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
345  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
346  EXPECT_EQ(root_node->GetName(), "root");
347 
348  EXPECT_EQ(child1_node->GetChildCount(), 0);
349  EXPECT_EQ(child1_node->GetName(), "child 1");
350 
351  EXPECT_EQ(child2_node->GetChildCount(), 0);
352  EXPECT_EQ(child2_node->GetName(), "child 2");
353 
354  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
355 
356  // Child2 is moved from child1 to root.
357  EXPECT_THAT(bridge->accessibility_events,
358  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
359  EXPECT_THAT(bridge->accessibility_events,
360  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
361 
362  // Child1 is no longer a parent. It loses its group role and disables its
363  // 'clip children' attribute.
364  EXPECT_THAT(
365  bridge->accessibility_events,
366  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
367  EXPECT_THAT(bridge->accessibility_events,
368  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
369 }

References CreateSemanticsNode().

◆ TEST() [9/158]

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

Definition at line 466 of file accessibility_bridge_unittests.cc.

466  {
467  std::shared_ptr<TestAccessibilityBridge> bridge =
468  std::make_shared<TestAccessibilityBridge>();
469 
470  int32_t root_id = 0;
471  int32_t intermediary1_id = 1;
472  int32_t intermediary2_id = 2;
473  int32_t leaf1_id = 3;
474 
475  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
476  std::vector<int32_t> intermediary1_children{leaf1_id};
477  FlutterSemanticsNode2 root =
478  CreateSemanticsNode(root_id, "root", &root_children);
479  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
480  intermediary1_id, "intermediary 1", &intermediary1_children);
481  FlutterSemanticsNode2 intermediary2 =
482  CreateSemanticsNode(intermediary2_id, "intermediary 2");
483  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
484 
485  bridge->AddFlutterSemanticsNodeUpdate(root);
486  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
487  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
488  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
489  bridge->CommitUpdates();
490  bridge->accessibility_events.clear();
491 
492  // Move intermediary1 from root to intermediary 2.
493  int32_t new_root_children[] = {intermediary2_id};
494  root.child_count = 1;
495  root.children_in_traversal_order = new_root_children;
496 
497  int32_t new_intermediary2_children[] = {intermediary1_id};
498  intermediary2.child_count = 1;
499  intermediary2.children_in_traversal_order = new_intermediary2_children;
500 
501  bridge->AddFlutterSemanticsNodeUpdate(root);
502  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
503  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
504  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
505  bridge->CommitUpdates();
506 
507  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
508  auto intermediary1_node =
509  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
510  auto intermediary2_node =
511  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
512  auto leaf1_node =
513  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
514 
515  EXPECT_EQ(root_node->GetChildCount(), 1);
516  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary2_id);
517  EXPECT_EQ(root_node->GetName(), "root");
518 
519  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
520  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], intermediary1_id);
521  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
522 
523  EXPECT_EQ(intermediary1_node->GetChildCount(), 1);
524  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf1_id);
525  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
526 
527  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
528  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
529 
530  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
531 
532  EXPECT_THAT(bridge->accessibility_events,
533  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
534  EXPECT_THAT(bridge->accessibility_events,
535  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
536 
537  // Intermediary 2 becomes a parent node. It updates to group role and enables
538  // its 'clip children' attribute.
539  EXPECT_THAT(
540  bridge->accessibility_events,
541  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
542  EXPECT_THAT(bridge->accessibility_events,
543  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
544 }

References CreateSemanticsNode().

◆ TEST() [10/158]

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

Definition at line 292 of file accessibility_bridge_unittests.cc.

292  {
293  std::shared_ptr<TestAccessibilityBridge> bridge =
294  std::make_shared<TestAccessibilityBridge>();
295  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
296  root.flags = static_cast<FlutterSemanticsFlag>(
297  FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState |
298  FlutterSemanticsFlag::kFlutterSemanticsFlagIsChecked);
299  bridge->AddFlutterSemanticsNodeUpdate(root);
300  bridge->CommitUpdates();
301 
302  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
303  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
304  EXPECT_EQ(root_node->GetData().GetCheckedState(),
305  ax::mojom::CheckedState::kTrue);
306 }

References CreateSemanticsNode().

◆ TEST() [11/158]

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

Definition at line 240 of file accessibility_bridge_unittests.cc.

240  {
241  std::shared_ptr<TestAccessibilityBridge> bridge =
242  std::make_shared<TestAccessibilityBridge>();
243  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
244  root.flags = static_cast<FlutterSemanticsFlag>(
245  FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField |
246  FlutterSemanticsFlag::kFlutterSemanticsFlagIsReadOnly);
247  bridge->AddFlutterSemanticsNodeUpdate(root);
248  bridge->CommitUpdates();
249 
250  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
251 
252  EXPECT_FALSE(root_node->GetData().GetBoolAttribute(
253  ax::mojom::BoolAttribute::kEditableRoot));
254 }

References CreateSemanticsNode().

◆ TEST() [12/158]

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

Definition at line 556 of file accessibility_bridge_unittests.cc.

556  {
557  std::shared_ptr<TestAccessibilityBridge> bridge =
558  std::make_shared<TestAccessibilityBridge>();
559 
560  const int32_t root_id = 0;
561 
562  FlutterSemanticsNode2 root = CreateSemanticsNode(root_id, "root", {});
563 
564  bridge->AddFlutterSemanticsNodeUpdate(root);
565  bridge->CommitUpdates();
566 
567  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
568  auto root_data = root_node->GetData();
569  EXPECT_TRUE(root_data.HasBoolAttribute(
570  ax::mojom::BoolAttribute::kIsLineBreakingObject));
571  EXPECT_TRUE(root_data.GetBoolAttribute(
572  ax::mojom::BoolAttribute::kIsLineBreakingObject));
573 }

References CreateSemanticsNode().

◆ TEST() [13/158]

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

Definition at line 271 of file accessibility_bridge_unittests.cc.

271  {
272  std::shared_ptr<TestAccessibilityBridge> bridge =
273  std::make_shared<TestAccessibilityBridge>();
274  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
275  root.flags = static_cast<FlutterSemanticsFlag>(
276  FlutterSemanticsFlag::kFlutterSemanticsFlagIsSlider |
277  FlutterSemanticsFlag::kFlutterSemanticsFlagHasEnabledState |
278  FlutterSemanticsFlag::kFlutterSemanticsFlagIsEnabled |
279  FlutterSemanticsFlag::kFlutterSemanticsFlagIsFocusable);
280  bridge->AddFlutterSemanticsNodeUpdate(root);
281  bridge->CommitUpdates();
282 
283  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
284  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSlider);
285 }

References CreateSemanticsNode().

◆ TEST() [14/158]

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

Definition at line 256 of file accessibility_bridge_unittests.cc.

256  {
257  std::shared_ptr<TestAccessibilityBridge> bridge =
258  std::make_shared<TestAccessibilityBridge>();
259  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
260  root.flags = static_cast<FlutterSemanticsFlag>(
261  FlutterSemanticsFlag::kFlutterSemanticsFlagHasToggledState |
262  FlutterSemanticsFlag::kFlutterSemanticsFlagHasEnabledState |
263  FlutterSemanticsFlag::kFlutterSemanticsFlagIsEnabled);
264  bridge->AddFlutterSemanticsNodeUpdate(root);
265  bridge->CommitUpdates();
266 
267  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
268  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
269 }

References CreateSemanticsNode().

◆ TEST() [15/158]

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

Definition at line 269 of file accessibility_bridge_windows_unittests.cc.

269  {
270  auto engine = GetTestEngine();
271  FlutterWindowsViewSpy view{
272  engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
273  EngineModifier modifier{engine.get()};
274  modifier.SetImplicitView(&view);
275  view.OnUpdateSemanticsEnabled(true);
276 
277  auto bridge = view.accessibility_bridge().lock();
278  PopulateAXTree(bridge);
279 
280  FlutterSemanticsAction actual_action = kFlutterSemanticsActionTap;
281  modifier.embedder_api().DispatchSemanticsAction = MOCK_ENGINE_PROC(
282  DispatchSemanticsAction,
283  ([&actual_action](FLUTTER_API_SYMBOL(FlutterEngine) engine, uint64_t id,
284  FlutterSemanticsAction action, const uint8_t* data,
285  size_t data_length) {
286  actual_action = action;
287  return kSuccess;
288  }));
289 
290  AccessibilityBridgeWindows delegate(&view);
291  delegate.DispatchAccessibilityAction(1, kFlutterSemanticsActionCopy, {});
292  EXPECT_EQ(actual_action, kFlutterSemanticsActionCopy);
293 }

References action, and flutter::AccessibilityBridgeWindows::DispatchAccessibilityAction().

◆ TEST() [16/158]

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

Definition at line 237 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [17/158]

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

Definition at line 254 of file accessibility_bridge_windows_unittests.cc.

254  {
255  auto engine = GetTestEngine();
256  FlutterWindowsViewSpy view{
257  engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
258  EngineModifier modifier{engine.get()};
259  modifier.SetImplicitView(&view);
260  view.OnUpdateSemanticsEnabled(true);
261 
262  auto bridge = view.accessibility_bridge().lock();
263  PopulateAXTree(bridge);
264 
265  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
266  ASSERT_TRUE(node0_delegate->GetParent() == nullptr);
267 }

◆ TEST() [18/158]

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

Definition at line 295 of file accessibility_bridge_windows_unittests.cc.

295  {
296  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::ALERT,
297  ax::mojom::Event::kAlert);
298 }

◆ TEST() [19/158]

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

Definition at line 300 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [20/158]

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

Definition at line 305 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [21/158]

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

Definition at line 329 of file accessibility_bridge_windows_unittests.cc.

329  {
330  // Static test nodes with no text, hint, or scrollability are ignored.
331  ExpectWinEventFromAXEvent(4, ui::AXEventGenerator::Event::IGNORED_CHANGED,
332  ax::mojom::Event::kHide);
333 }

◆ TEST() [22/158]

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

Definition at line 351 of file accessibility_bridge_windows_unittests.cc.

351  {
352  ExpectWinEventFromAXEvent(
353  1, ui::AXEventGenerator::Event::SCROLL_HORIZONTAL_POSITION_CHANGED,
354  ax::mojom::Event::kScrollPositionChanged);
355 }

◆ TEST() [23/158]

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

Definition at line 335 of file accessibility_bridge_windows_unittests.cc.

335  {
336  ExpectWinEventFromAXEvent(
337  1, ui::AXEventGenerator::Event::IMAGE_ANNOTATION_CHANGED,
338  ax::mojom::Event::kTextChanged);
339 }

◆ TEST() [24/158]

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

Definition at line 341 of file accessibility_bridge_windows_unittests.cc.

341  {
342  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::LIVE_REGION_CHANGED,
343  ax::mojom::Event::kLiveRegionChanged);
344 }

◆ TEST() [25/158]

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

Definition at line 346 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [26/158]

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

Definition at line 363 of file accessibility_bridge_windows_unittests.cc.

363  {
364  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::SELECTED_CHANGED,
365  ax::mojom::Event::kValueChanged);
366 }

◆ TEST() [27/158]

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

Definition at line 368 of file accessibility_bridge_windows_unittests.cc.

368  {
369  ExpectWinEventFromAXEvent(
370  2, ui::AXEventGenerator::Event::SELECTED_CHILDREN_CHANGED,
371  ax::mojom::Event::kSelectedChildrenChanged);
372 }

◆ TEST() [28/158]

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

Definition at line 384 of file accessibility_bridge_windows_unittests.cc.

384  {
385  ExpectWinEventFromAXEvent(
386  1, ui::AXEventGenerator::Event::WIN_IACCESSIBLE_STATE_CHANGED,
387  ax::mojom::Event::kStateChanged);
388 }

◆ TEST() [29/158]

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

Definition at line 374 of file accessibility_bridge_windows_unittests.cc.

374  {
375  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::SUBTREE_CREATED,
376  ax::mojom::Event::kShow);
377 }

◆ TEST() [30/158]

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

Definition at line 379 of file accessibility_bridge_windows_unittests.cc.

379  {
380  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::VALUE_CHANGED,
381  ax::mojom::Event::kValueChanged);
382 }

◆ TEST() [31/158]

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

Definition at line 357 of file accessibility_bridge_windows_unittests.cc.

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

◆ TEST() [32/158]

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

Definition at line 390 of file accessibility_bridge_windows_unittests.cc.

390  {
391  ExpectWinEventFromAXEventOnFocusNode(
392  1, ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED,
393  ax::mojom::Event::kDocumentSelectionChanged, 2);
394 }

◆ TEST() [33/158]

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 }

References content.

◆ TEST() [34/158]

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

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

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

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

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

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

◆ TEST() [39/158]

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

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

Definition at line 110 of file flutter_platform_node_delegate_unittests.cc.

110  {
111  std::shared_ptr<TestAccessibilityBridge> bridge =
112  std::make_shared<TestAccessibilityBridge>();
113  FlutterSemanticsNode2 root;
114  root.id = 0;
115  root.label = "root";
116  root.hint = "";
117  root.value = "";
118  root.increased_value = "";
119  root.decreased_value = "";
120  root.tooltip = "";
121  root.child_count = 1;
122  int32_t children[] = {1};
123  root.children_in_traversal_order = children;
124  root.custom_accessibility_actions_count = 0;
125  root.rect = {0, 0, 100, 100}; // LTRB
126  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
127  bridge->AddFlutterSemanticsNodeUpdate(root);
128 
129  FlutterSemanticsNode2 child1;
130  child1.id = 1;
131  child1.label = "child 1";
132  child1.hint = "";
133  child1.value = "";
134  child1.increased_value = "";
135  child1.decreased_value = "";
136  child1.tooltip = "";
137  child1.child_count = 0;
138  child1.custom_accessibility_actions_count = 0;
139  child1.rect = {0, 0, 50, 50}; // LTRB
140  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
141  bridge->AddFlutterSemanticsNodeUpdate(child1);
142 
143  bridge->CommitUpdates();
144  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
145  ui::AXOffscreenResult result;
146  gfx::Rect bounds =
147  child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
148  ui::AXClippingBehavior::kClipped, &result);
149  EXPECT_EQ(bounds.x(), 0);
150  EXPECT_EQ(bounds.y(), 0);
151  EXPECT_EQ(bounds.width(), 25);
152  EXPECT_EQ(bounds.height(), 25);
153  EXPECT_EQ(result, ui::AXOffscreenResult::kOnscreen);
154 }

◆ TEST() [41/158]

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

Definition at line 156 of file flutter_platform_node_delegate_unittests.cc.

156  {
157  std::shared_ptr<TestAccessibilityBridge> bridge =
158  std::make_shared<TestAccessibilityBridge>();
159  FlutterSemanticsNode2 root;
160  root.id = 0;
161  root.label = "root";
162  root.hint = "";
163  root.value = "";
164  root.increased_value = "";
165  root.decreased_value = "";
166  root.tooltip = "";
167  root.child_count = 1;
168  int32_t children[] = {1};
169  root.children_in_traversal_order = children;
170  root.custom_accessibility_actions_count = 0;
171  root.rect = {0, 0, 100, 100}; // LTRB
172  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
173  bridge->AddFlutterSemanticsNodeUpdate(root);
174 
175  FlutterSemanticsNode2 child1;
176  child1.id = 1;
177  child1.label = "child 1";
178  child1.hint = "";
179  child1.value = "";
180  child1.increased_value = "";
181  child1.decreased_value = "";
182  child1.tooltip = "";
183  child1.child_count = 0;
184  child1.custom_accessibility_actions_count = 0;
185  child1.rect = {90, 90, 100, 100}; // LTRB
186  child1.transform = {2, 0, 0, 0, 2, 0, 0, 0, 1};
187  bridge->AddFlutterSemanticsNodeUpdate(child1);
188 
189  bridge->CommitUpdates();
190  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
191  ui::AXOffscreenResult result;
192  gfx::Rect bounds =
193  child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
194  ui::AXClippingBehavior::kUnclipped, &result);
195  EXPECT_EQ(bounds.x(), 180);
196  EXPECT_EQ(bounds.y(), 180);
197  EXPECT_EQ(bounds.width(), 20);
198  EXPECT_EQ(bounds.height(), 20);
199  EXPECT_EQ(result, ui::AXOffscreenResult::kOffscreen);
200 }

◆ TEST() [42/158]

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

Definition at line 84 of file flutter_platform_node_delegate_unittests.cc.

84  {
85  // Set up a flutter accessibility node.
86  std::shared_ptr<TestAccessibilityBridge> bridge =
87  std::make_shared<TestAccessibilityBridge>();
88  FlutterSemanticsNode2 root;
89  root.id = 0;
90  root.flags = FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField;
91  root.actions = static_cast<FlutterSemanticsAction>(0);
92  root.text_selection_base = -1;
93  root.text_selection_extent = -1;
94  root.label = "root";
95  root.hint = "";
96  root.value = "";
97  root.increased_value = "";
98  root.decreased_value = "";
99  root.tooltip = "";
100  root.child_count = 0;
101  root.custom_accessibility_actions_count = 0;
102  bridge->AddFlutterSemanticsNodeUpdate(root);
103 
104  bridge->CommitUpdates();
105 
106  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
107  EXPECT_EQ(accessibility->GetData().id, 0);
108 }

◆ TEST() [43/158]

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

Definition at line 271 of file flutter_platform_node_delegate_unittests.cc.

271  {
272  std::shared_ptr<TestAccessibilityBridge> bridge =
273  std::make_shared<TestAccessibilityBridge>();
274  FlutterSemanticsNode2 root;
275  root.id = 0;
276  root.label = "root";
277  root.hint = "";
278  root.value = "";
279  root.increased_value = "";
280  root.decreased_value = "";
281  root.tooltip = "";
282  root.child_count = 1;
283  int32_t children[] = {1};
284  root.children_in_traversal_order = children;
285  root.custom_accessibility_actions_count = 0;
286  bridge->AddFlutterSemanticsNodeUpdate(root);
287 
288  FlutterSemanticsNode2 child1;
289  child1.id = 1;
290  child1.label = "child 1";
291  child1.hint = "";
292  child1.value = "";
293  child1.increased_value = "";
294  child1.decreased_value = "";
295  child1.tooltip = "";
296  child1.child_count = 0;
297  child1.custom_accessibility_actions_count = 0;
298  bridge->AddFlutterSemanticsNodeUpdate(child1);
299 
300  bridge->CommitUpdates();
301  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
302  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
303  auto node_by_id = root_node->GetFromNodeID(1);
304  EXPECT_EQ(child1_node->GetPlatformNode(), node_by_id);
305 }

◆ TEST() [44/158]

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

Definition at line 40 of file flutter_platform_node_delegate_unittests.cc.

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

◆ TEST() [45/158]

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

Definition at line 202 of file flutter_platform_node_delegate_unittests.cc.

202  {
203  std::shared_ptr<TestAccessibilityBridge> bridge =
204  std::make_shared<TestAccessibilityBridge>();
205  FlutterSemanticsNode2 root;
206  root.id = 0;
207  root.label = "root";
208  root.hint = "";
209  root.value = "";
210  root.increased_value = "";
211  root.decreased_value = "";
212  root.tooltip = "";
213  root.child_count = 1;
214  int32_t children[] = {1};
215  root.children_in_traversal_order = children;
216  root.custom_accessibility_actions_count = 0;
217  root.rect = {0, 0, 100, 100}; // LTRB
218  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
219  bridge->AddFlutterSemanticsNodeUpdate(root);
220 
221  FlutterSemanticsNode2 child1;
222  child1.id = 1;
223  child1.label = "child 1";
224  child1.hint = "";
225  child1.value = "";
226  child1.increased_value = "";
227  child1.decreased_value = "";
228  child1.tooltip = "";
229  child1.child_count = 0;
230  child1.custom_accessibility_actions_count = 0;
231  child1.rect = {0, 0, 50, 50}; // LTRB
232  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
233  bridge->AddFlutterSemanticsNodeUpdate(child1);
234 
235  bridge->CommitUpdates();
236  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
237  auto owner_bridge = child1_node->GetOwnerBridge().lock();
238 
239  bool result;
240  gfx::RectF bounds = owner_bridge->RelativeToGlobalBounds(
241  child1_node->GetAXNode(), result, true);
242  EXPECT_EQ(bounds.x(), 0);
243  EXPECT_EQ(bounds.y(), 0);
244  EXPECT_EQ(bounds.width(), 25);
245  EXPECT_EQ(bounds.height(), 25);
246  EXPECT_EQ(result, false);
247 }

◆ TEST() [46/158]

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  node0.child_count = node0_children.size();
23  node0.children_in_traversal_order = node0_children.data();
24  node0.children_in_hit_test_order = node0_children.data();
25 
26  // Add node 1: text child of node 0.
27  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
28  node1.label = "prefecture";
29  node1.value = "Kyoto";
30 
31  bridge->AddFlutterSemanticsNodeUpdate(node0);
32  bridge->AddFlutterSemanticsNodeUpdate(node1);
33  bridge->CommitUpdates();
34 
35  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
36  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
37  EXPECT_TRUE(node0_delegate->GetUniqueId() != node1_delegate->GetUniqueId());
38 }

◆ TEST() [47/158]

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

Definition at line 249 of file flutter_platform_node_delegate_unittests.cc.

249  {
250  std::shared_ptr<TestAccessibilityBridge> bridge =
251  std::make_shared<TestAccessibilityBridge>();
252  FlutterSemanticsNode2 root;
253  root.id = 0;
254  root.label = "root";
255  root.hint = "";
256  root.value = "";
257  root.increased_value = "";
258  root.decreased_value = "";
259  root.tooltip = "";
260  root.child_count = 0;
261  root.children_in_traversal_order = nullptr;
262  root.custom_accessibility_actions_count = 0;
263  bridge->AddFlutterSemanticsNodeUpdate(root);
264 
265  bridge->CommitUpdates();
266  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
267  auto lowest_platform_ancestor = root_node->GetLowestPlatformAncestor();
268  EXPECT_EQ(root_node->GetNativeViewAccessible(), lowest_platform_ancestor);
269 }

◆ TEST() [48/158]

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

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

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

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

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

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

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 }

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, user_data, FlutterDesktopGpuSurfaceTextureConfig::user_data, FlutterDesktopGpuSurfaceDescriptor::visible_height, FlutterDesktopGpuSurfaceDescriptor::visible_width, and FlutterDesktopGpuSurfaceDescriptor::width.

◆ TEST() [55/158]

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 }

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, user_data, FlutterDesktopGpuSurfaceTextureConfig::user_data, FlutterDesktopGpuSurfaceDescriptor::visible_height, FlutterDesktopGpuSurfaceDescriptor::visible_width, and FlutterDesktopGpuSurfaceDescriptor::width.

◆ TEST() [56/158]

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

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 }

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, user_data, FlutterDesktopPixelBufferTextureConfig::user_data, and FlutterDesktopPixelBuffer::width.

◆ TEST() [58/158]

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 }

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

◆ TEST() [59/158]

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 }

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

◆ TEST() [60/158]

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

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

Definition at line 724 of file flutter_windows_view_unittests.cc.

724  {
725  constexpr FlutterTransformation kIdentityTransform = {1, 0, 0, //
726  0, 1, 0, //
727  0, 0, 1};
728 
729  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
730  EngineModifier modifier(engine.get());
731  modifier.embedder_api().UpdateSemanticsEnabled =
732  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
733  return kSuccess;
734  };
735 
736  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
737  std::make_unique<NiceMock<MockWindowBindingHandler>>());
738 
739  // Enable semantics to instantiate accessibility bridge.
740  view->OnUpdateSemanticsEnabled(true);
741 
742  auto bridge = view->accessibility_bridge().lock();
743  ASSERT_TRUE(bridge);
744 
745  // Add root node at origin. Size 500x500.
746  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
747  std::vector<int32_t> node0_children{1, 2};
748  node0.rect = {0, 0, 500, 500};
749  node0.transform = kIdentityTransform;
750  node0.child_count = node0_children.size();
751  node0.children_in_traversal_order = node0_children.data();
752  node0.children_in_hit_test_order = node0_children.data();
753 
754  // Add node 1 located at 0,0 relative to node 0. Size 250x500.
755  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
756  node1.rect = {0, 0, 250, 500};
757  node1.transform = kIdentityTransform;
758  node1.label = "prefecture";
759  node1.value = "Kyoto";
760 
761  // Add node 2 located at 250,0 relative to node 0. Size 250x500.
762  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
763  std::vector<int32_t> node2_children{3};
764  node2.rect = {0, 0, 250, 500};
765  node2.transform = {1, 0, 250, 0, 1, 0, 0, 0, 1};
766  node2.child_count = node2_children.size();
767  node2.children_in_traversal_order = node2_children.data();
768  node2.children_in_hit_test_order = node2_children.data();
769 
770  // Add node 3 located at 0,250 relative to node 2. Size 250, 250.
771  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
772  node3.rect = {0, 0, 250, 250};
773  node3.transform = {1, 0, 0, 0, 1, 250, 0, 0, 1};
774  node3.label = "city";
775  node3.value = "Uji";
776 
777  bridge->AddFlutterSemanticsNodeUpdate(node0);
778  bridge->AddFlutterSemanticsNodeUpdate(node1);
779  bridge->AddFlutterSemanticsNodeUpdate(node2);
780  bridge->AddFlutterSemanticsNodeUpdate(node3);
781  bridge->CommitUpdates();
782 
783  // Look up the root windows node delegate.
784  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
785  ASSERT_TRUE(node0_delegate);
786  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
787  ASSERT_TRUE(node1_delegate);
788  auto node2_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
789  ASSERT_TRUE(node2_delegate);
790  auto node3_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(3).lock();
791  ASSERT_TRUE(node3_delegate);
792 
793  // Get the native IAccessible root object.
794  IAccessible* node0_accessible = node0_delegate->GetNativeViewAccessible();
795  ASSERT_TRUE(node0_accessible != nullptr);
796 
797  // Perform a hit test that should hit node 1.
798  VARIANT varchild{};
799  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(150, 150, &varchild)));
800  EXPECT_EQ(varchild.vt, VT_DISPATCH);
801  EXPECT_EQ(varchild.pdispVal, node1_delegate->GetNativeViewAccessible());
802 
803  // Perform a hit test that should hit node 2.
804  varchild = {};
805  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 150, &varchild)));
806  EXPECT_EQ(varchild.vt, VT_DISPATCH);
807  EXPECT_EQ(varchild.pdispVal, node2_delegate->GetNativeViewAccessible());
808 
809  // Perform a hit test that should hit node 3.
810  varchild = {};
811  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 450, &varchild)));
812  EXPECT_EQ(varchild.vt, VT_DISPATCH);
813  EXPECT_EQ(varchild.pdispVal, node3_delegate->GetNativeViewAccessible());
814 }

◆ TEST() [62/158]

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

Definition at line 303 of file flutter_windows_view_unittests.cc.

303  {
304  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
305  EngineModifier modifier(engine.get());
306  modifier.embedder_api().UpdateSemanticsEnabled =
307  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
308  return kSuccess;
309  };
310 
311  auto window_binding_handler =
312  std::make_unique<NiceMock<MockWindowBindingHandler>>();
313  std::unique_ptr<FlutterWindowsView> view =
314  engine->CreateView(std::move(window_binding_handler));
315 
316  // Enable semantics to instantiate accessibility bridge.
317  view->OnUpdateSemanticsEnabled(true);
318 
319  auto bridge = view->accessibility_bridge().lock();
320  ASSERT_TRUE(bridge);
321 
322  // Add root node.
323  FlutterSemanticsNode2 node{sizeof(FlutterSemanticsNode2), 0};
324  node.label = "name";
325  node.value = "value";
326  node.platform_view_id = -1;
327  bridge->AddFlutterSemanticsNodeUpdate(node);
328  bridge->CommitUpdates();
329 
330  // Look up the root windows node delegate.
331  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
332  ASSERT_TRUE(node_delegate);
333  EXPECT_EQ(node_delegate->GetChildCount(), 0);
334 
335  // Get the native IAccessible object.
336  IAccessible* native_view = node_delegate->GetNativeViewAccessible();
337  ASSERT_TRUE(native_view != nullptr);
338 
339  // Property lookups will be made against this node itself.
340  VARIANT varchild{};
341  varchild.vt = VT_I4;
342  varchild.lVal = CHILDID_SELF;
343 
344  // Verify node name matches our label.
345  BSTR bname = nullptr;
346  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
347  std::string name(_com_util::ConvertBSTRToString(bname));
348  EXPECT_EQ(name, "name");
349 
350  // Verify node value matches.
351  BSTR bvalue = nullptr;
352  ASSERT_EQ(native_view->get_accValue(varchild, &bvalue), S_OK);
353  std::string value(_com_util::ConvertBSTRToString(bvalue));
354  EXPECT_EQ(value, "value");
355 
356  // Verify node type is static text.
357  VARIANT varrole{};
358  varrole.vt = VT_I4;
359  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
360  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
361 
362  // Get the IRawElementProviderFragment object.
363  IRawElementProviderSimple* uia_view;
364  native_view->QueryInterface(IID_PPV_ARGS(&uia_view));
365  ASSERT_TRUE(uia_view != nullptr);
366 
367  // Verify name property matches our label.
368  VARIANT varname{};
369  ASSERT_EQ(uia_view->GetPropertyValue(UIA_NamePropertyId, &varname), S_OK);
370  EXPECT_EQ(varname.vt, VT_BSTR);
371  name = _com_util::ConvertBSTRToString(varname.bstrVal);
372  EXPECT_EQ(name, "name");
373 
374  // Verify value property matches our label.
375  VARIANT varvalue{};
376  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ValueValuePropertyId, &varvalue),
377  S_OK);
378  EXPECT_EQ(varvalue.vt, VT_BSTR);
379  value = _com_util::ConvertBSTRToString(varvalue.bstrVal);
380  EXPECT_EQ(value, "value");
381 
382  // Verify node control type is text.
383  varrole = {};
384  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
385  S_OK);
386  EXPECT_EQ(varrole.vt, VT_I4);
387  EXPECT_EQ(varrole.lVal, UIA_TextControlTypeId);
388 }

References node_delegate.

◆ TEST() [63/158]

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

Definition at line 402 of file flutter_windows_view_unittests.cc.

402  {
403  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
404  EngineModifier modifier(engine.get());
405  modifier.embedder_api().UpdateSemanticsEnabled =
406  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
407  return kSuccess;
408  };
409 
410  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
411  std::make_unique<NiceMock<MockWindowBindingHandler>>());
412 
413  // Enable semantics to instantiate accessibility bridge.
414  view->OnUpdateSemanticsEnabled(true);
415 
416  auto bridge = view->accessibility_bridge().lock();
417  ASSERT_TRUE(bridge);
418 
419  // Add root node.
420  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
421  std::vector<int32_t> node0_children{1, 2};
422  node0.child_count = node0_children.size();
423  node0.children_in_traversal_order = node0_children.data();
424  node0.children_in_hit_test_order = node0_children.data();
425 
426  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
427  node1.label = "prefecture";
428  node1.value = "Kyoto";
429  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
430  std::vector<int32_t> node2_children{3};
431  node2.child_count = node2_children.size();
432  node2.children_in_traversal_order = node2_children.data();
433  node2.children_in_hit_test_order = node2_children.data();
434  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
435  node3.label = "city";
436  node3.value = "Uji";
437 
438  bridge->AddFlutterSemanticsNodeUpdate(node0);
439  bridge->AddFlutterSemanticsNodeUpdate(node1);
440  bridge->AddFlutterSemanticsNodeUpdate(node2);
441  bridge->AddFlutterSemanticsNodeUpdate(node3);
442  bridge->CommitUpdates();
443 
444  // Look up the root windows node delegate.
445  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
446  ASSERT_TRUE(node_delegate);
447  EXPECT_EQ(node_delegate->GetChildCount(), 2);
448 
449  // Get the native IAccessible object.
450  IAccessible* node0_accessible = node_delegate->GetNativeViewAccessible();
451  ASSERT_TRUE(node0_accessible != nullptr);
452 
453  // Property lookups will be made against this node itself.
454  VARIANT varchild{};
455  varchild.vt = VT_I4;
456  varchild.lVal = CHILDID_SELF;
457 
458  // Verify node type is a group.
459  VARIANT varrole{};
460  varrole.vt = VT_I4;
461  ASSERT_EQ(node0_accessible->get_accRole(varchild, &varrole), S_OK);
462  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
463 
464  // Verify child count.
465  long node0_child_count = 0;
466  ASSERT_EQ(node0_accessible->get_accChildCount(&node0_child_count), S_OK);
467  EXPECT_EQ(node0_child_count, 2);
468 
469  {
470  // Look up first child of node0 (node1), a static text node.
471  varchild.lVal = 1;
472  IDispatch* node1_dispatch = nullptr;
473  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node1_dispatch), S_OK);
474  ASSERT_TRUE(node1_dispatch != nullptr);
475  IAccessible* node1_accessible = nullptr;
476  ASSERT_EQ(node1_dispatch->QueryInterface(
477  IID_IAccessible, reinterpret_cast<void**>(&node1_accessible)),
478  S_OK);
479  ASSERT_TRUE(node1_accessible != nullptr);
480 
481  // Verify node name matches our label.
482  varchild.lVal = CHILDID_SELF;
483  BSTR bname = nullptr;
484  ASSERT_EQ(node1_accessible->get_accName(varchild, &bname), S_OK);
485  std::string name(_com_util::ConvertBSTRToString(bname));
486  EXPECT_EQ(name, "prefecture");
487 
488  // Verify node value matches.
489  BSTR bvalue = nullptr;
490  ASSERT_EQ(node1_accessible->get_accValue(varchild, &bvalue), S_OK);
491  std::string value(_com_util::ConvertBSTRToString(bvalue));
492  EXPECT_EQ(value, "Kyoto");
493 
494  // Verify node type is static text.
495  VARIANT varrole{};
496  varrole.vt = VT_I4;
497  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
498  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
499 
500  // Verify the parent node is the root.
501  IDispatch* parent_dispatch;
502  node1_accessible->get_accParent(&parent_dispatch);
503  IAccessible* parent_accessible;
504  ASSERT_EQ(
505  parent_dispatch->QueryInterface(
506  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
507  S_OK);
508  EXPECT_EQ(parent_accessible, node0_accessible);
509  }
510 
511  // Look up second child of node0 (node2), a parent group for node3.
512  varchild.lVal = 2;
513  IDispatch* node2_dispatch = nullptr;
514  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
515  ASSERT_TRUE(node2_dispatch != nullptr);
516  IAccessible* node2_accessible = nullptr;
517  ASSERT_EQ(node2_dispatch->QueryInterface(
518  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
519  S_OK);
520  ASSERT_TRUE(node2_accessible != nullptr);
521 
522  {
523  // Verify child count.
524  long node2_child_count = 0;
525  ASSERT_EQ(node2_accessible->get_accChildCount(&node2_child_count), S_OK);
526  EXPECT_EQ(node2_child_count, 1);
527 
528  // Verify node type is static text.
529  varchild.lVal = CHILDID_SELF;
530  VARIANT varrole{};
531  varrole.vt = VT_I4;
532  ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
533  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
534 
535  // Verify the parent node is the root.
536  IDispatch* parent_dispatch;
537  node2_accessible->get_accParent(&parent_dispatch);
538  IAccessible* parent_accessible;
539  ASSERT_EQ(
540  parent_dispatch->QueryInterface(
541  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
542  S_OK);
543  EXPECT_EQ(parent_accessible, node0_accessible);
544  }
545 
546  {
547  // Look up only child of node2 (node3), a static text node.
548  varchild.lVal = 1;
549  IDispatch* node3_dispatch = nullptr;
550  ASSERT_EQ(node2_accessible->get_accChild(varchild, &node3_dispatch), S_OK);
551  ASSERT_TRUE(node3_dispatch != nullptr);
552  IAccessible* node3_accessible = nullptr;
553  ASSERT_EQ(node3_dispatch->QueryInterface(
554  IID_IAccessible, reinterpret_cast<void**>(&node3_accessible)),
555  S_OK);
556  ASSERT_TRUE(node3_accessible != nullptr);
557 
558  // Verify node name matches our label.
559  varchild.lVal = CHILDID_SELF;
560  BSTR bname = nullptr;
561  ASSERT_EQ(node3_accessible->get_accName(varchild, &bname), S_OK);
562  std::string name(_com_util::ConvertBSTRToString(bname));
563  EXPECT_EQ(name, "city");
564 
565  // Verify node value matches.
566  BSTR bvalue = nullptr;
567  ASSERT_EQ(node3_accessible->get_accValue(varchild, &bvalue), S_OK);
568  std::string value(_com_util::ConvertBSTRToString(bvalue));
569  EXPECT_EQ(value, "Uji");
570 
571  // Verify node type is static text.
572  VARIANT varrole{};
573  varrole.vt = VT_I4;
574  ASSERT_EQ(node3_accessible->get_accRole(varchild, &varrole), S_OK);
575  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
576 
577  // Verify the parent node is node2.
578  IDispatch* parent_dispatch;
579  node3_accessible->get_accParent(&parent_dispatch);
580  IAccessible* parent_accessible;
581  ASSERT_EQ(
582  parent_dispatch->QueryInterface(
583  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
584  S_OK);
585  EXPECT_EQ(parent_accessible, node2_accessible);
586  }
587 }

References node_delegate.

◆ TEST() [64/158]

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

Definition at line 1052 of file flutter_windows_view_unittests.cc.

1052  {
1053  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1054  EngineModifier modifier(engine.get());
1055  modifier.embedder_api().UpdateSemanticsEnabled =
1056  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1057  return kSuccess;
1058  };
1059 
1060  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1061  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1062 
1063  // Enable semantics to instantiate accessibility bridge.
1064  view->OnUpdateSemanticsEnabled(true);
1065 
1066  auto bridge = view->accessibility_bridge().lock();
1067  ASSERT_TRUE(bridge);
1068 
1069  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1070  root.id = 0;
1071  root.label = "root";
1072  root.hint = "";
1073  root.value = "";
1074  root.increased_value = "";
1075  root.decreased_value = "";
1076  root.child_count = 0;
1077  root.custom_accessibility_actions_count = 0;
1078  root.flags = static_cast<FlutterSemanticsFlag>(
1079  FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState |
1080  FlutterSemanticsFlag::kFlutterSemanticsFlagIsChecked);
1081  bridge->AddFlutterSemanticsNodeUpdate(root);
1082 
1083  bridge->CommitUpdates();
1084 
1085  {
1086  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1087  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1088  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1089  ax::mojom::CheckedState::kTrue);
1090 
1091  // Get the IAccessible for the root node.
1092  IAccessible* native_view = root_node->GetNativeViewAccessible();
1093  ASSERT_TRUE(native_view != nullptr);
1094 
1095  // Look up against the node itself (not one of its children).
1096  VARIANT varchild = {};
1097  varchild.vt = VT_I4;
1098 
1099  // Verify the checkbox is checked.
1100  varchild.lVal = CHILDID_SELF;
1101  VARIANT native_state = {};
1102  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1103  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
1104 
1105  // Perform similar tests for UIA value;
1106  IRawElementProviderSimple* uia_node;
1107  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1108  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1109  UIA_ToggleToggleStatePropertyId, &native_state)));
1110  EXPECT_EQ(native_state.lVal, ToggleState_On);
1111 
1112  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1113  UIA_AriaPropertiesPropertyId, &native_state)));
1114  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=true"), nullptr);
1115  }
1116 
1117  // Test unchecked too.
1118  root.flags = static_cast<FlutterSemanticsFlag>(
1119  FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState);
1120  bridge->AddFlutterSemanticsNodeUpdate(root);
1121  bridge->CommitUpdates();
1122 
1123  {
1124  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1125  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1126  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1127  ax::mojom::CheckedState::kFalse);
1128 
1129  // Get the IAccessible for the root node.
1130  IAccessible* native_view = root_node->GetNativeViewAccessible();
1131  ASSERT_TRUE(native_view != nullptr);
1132 
1133  // Look up against the node itself (not one of its children).
1134  VARIANT varchild = {};
1135  varchild.vt = VT_I4;
1136 
1137  // Verify the checkbox is unchecked.
1138  varchild.lVal = CHILDID_SELF;
1139  VARIANT native_state = {};
1140  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1141  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
1142 
1143  // Perform similar tests for UIA value;
1144  IRawElementProviderSimple* uia_node;
1145  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1146  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1147  UIA_ToggleToggleStatePropertyId, &native_state)));
1148  EXPECT_EQ(native_state.lVal, ToggleState_Off);
1149 
1150  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1151  UIA_AriaPropertiesPropertyId, &native_state)));
1152  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=false"), nullptr);
1153  }
1154 
1155  // Now check mixed state.
1156  root.flags = static_cast<FlutterSemanticsFlag>(
1157  FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState |
1158  FlutterSemanticsFlag::kFlutterSemanticsFlagIsCheckStateMixed);
1159  bridge->AddFlutterSemanticsNodeUpdate(root);
1160  bridge->CommitUpdates();
1161 
1162  {
1163  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1164  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1165  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1166  ax::mojom::CheckedState::kMixed);
1167 
1168  // Get the IAccessible for the root node.
1169  IAccessible* native_view = root_node->GetNativeViewAccessible();
1170  ASSERT_TRUE(native_view != nullptr);
1171 
1172  // Look up against the node itself (not one of its children).
1173  VARIANT varchild = {};
1174  varchild.vt = VT_I4;
1175 
1176  // Verify the checkbox is mixed.
1177  varchild.lVal = CHILDID_SELF;
1178  VARIANT native_state = {};
1179  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1180  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_MIXED);
1181 
1182  // Perform similar tests for UIA value;
1183  IRawElementProviderSimple* uia_node;
1184  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1185  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1186  UIA_ToggleToggleStatePropertyId, &native_state)));
1187  EXPECT_EQ(native_state.lVal, ToggleState_Indeterminate);
1188 
1189  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1190  UIA_AriaPropertiesPropertyId, &native_state)));
1191  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=mixed"), nullptr);
1192  }
1193 }

◆ TEST() [65/158]

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

Definition at line 1447 of file flutter_windows_view_unittests.cc.

1447  {
1448  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1449  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1450  auto egl_manager = std::make_unique<egl::MockManager>();
1451  egl::MockContext render_context;
1452  auto surface = std::make_unique<egl::MockWindowSurface>();
1453  auto surface_ptr = surface.get();
1454 
1455  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1456  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1457  .WillOnce(Return(true));
1458 
1459  EXPECT_CALL(*egl_manager.get(), render_context)
1460  .WillOnce(Return(&render_context));
1461  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1462 
1463  InSequence s;
1464  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1465  .WillOnce(Return(std::move(surface)));
1466  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1467  .WillOnce([](fml::closure callback) {
1468  callback();
1469  return true;
1470  });
1471  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1472  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1473  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1474  EXPECT_CALL(*engine.get(), Stop).Times(1);
1475  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1476 
1477  EngineModifier modifier{engine.get()};
1478  modifier.SetEGLManager(std::move(egl_manager));
1479 
1480  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1481  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1482 
1483  view->CreateRenderSurface();
1484 }

References callback.

◆ TEST() [66/158]

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

Definition at line 1370 of file flutter_windows_view_unittests.cc.

1370  {
1371  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1372  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1373  auto egl_manager = std::make_unique<egl::MockManager>();
1374  egl::MockContext render_context;
1375  auto surface = std::make_unique<egl::MockWindowSurface>();
1376  auto surface_ptr = surface.get();
1377 
1378  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1379  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1380 
1381  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1382  .WillOnce(Return(true));
1383 
1384  EXPECT_CALL(*egl_manager.get(), render_context)
1385  .WillOnce(Return(&render_context));
1386  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1387 
1388  InSequence s;
1389  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1390  .WillOnce(Return(std::move(surface)));
1391  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1392  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1393  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1394 
1395  EXPECT_CALL(*engine.get(), Stop).Times(1);
1396  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1397 
1398  EngineModifier modifier{engine.get()};
1399  modifier.SetEGLManager(std::move(egl_manager));
1400 
1401  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1402  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1403 
1404  view->CreateRenderSurface();
1405 }

◆ TEST() [67/158]

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

Definition at line 281 of file flutter_windows_view_unittests.cc.

281  {
282  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
283  EngineModifier modifier(engine.get());
284 
285  bool semantics_enabled = false;
286  modifier.embedder_api().UpdateSemanticsEnabled = MOCK_ENGINE_PROC(
287  UpdateSemanticsEnabled,
288  [&semantics_enabled](FLUTTER_API_SYMBOL(FlutterEngine) engine,
289  bool enabled) {
290  semantics_enabled = enabled;
291  return kSuccess;
292  });
293 
294  auto window_binding_handler =
295  std::make_unique<NiceMock<MockWindowBindingHandler>>();
296  std::unique_ptr<FlutterWindowsView> view =
297  engine->CreateView(std::move(window_binding_handler));
298 
299  view->OnUpdateSemanticsEnabled(true);
300  EXPECT_TRUE(semantics_enabled);
301 }

◆ TEST() [68/158]

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

Definition at line 1488 of file flutter_windows_view_unittests.cc.

1488  {
1489  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1490  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1491  auto egl_manager = std::make_unique<egl::MockManager>();
1492  egl::MockContext render_context;
1493  auto surface = std::make_unique<egl::MockWindowSurface>();
1494  auto surface_ptr = surface.get();
1495 
1496  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1497 
1498  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1499  .WillOnce(Return(false));
1500 
1501  EXPECT_CALL(*egl_manager.get(), render_context)
1502  .WillOnce(Return(&render_context));
1503  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1504 
1505  InSequence s;
1506  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1507  .WillOnce(Return(std::move(surface)));
1508  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1509  .WillOnce([](fml::closure callback) {
1510  callback();
1511  return true;
1512  });
1513 
1514  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1515  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1516  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1517  EXPECT_CALL(*engine.get(), Stop).Times(1);
1518  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1519 
1520  EngineModifier modifier{engine.get()};
1521  modifier.SetEGLManager(std::move(egl_manager));
1522 
1523  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1524  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1525 
1526  view->CreateRenderSurface();
1527 }

References callback.

◆ TEST() [69/158]

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

Definition at line 1409 of file flutter_windows_view_unittests.cc.

1409  {
1410  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1411  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1412  auto egl_manager = std::make_unique<egl::MockManager>();
1413  egl::MockContext render_context;
1414  auto surface = std::make_unique<egl::MockWindowSurface>();
1415  auto surface_ptr = surface.get();
1416 
1417  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1418  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1419  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1420  .WillOnce(Return(false));
1421 
1422  EXPECT_CALL(*egl_manager.get(), render_context)
1423  .WillOnce(Return(&render_context));
1424  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1425 
1426  InSequence s;
1427  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1428  .WillOnce(Return(std::move(surface)));
1429  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1430  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1431  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1432 
1433  EXPECT_CALL(*engine.get(), Stop).Times(1);
1434  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1435 
1436  EngineModifier modifier{engine.get()};
1437  modifier.SetEGLManager(std::move(egl_manager));
1438 
1439  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1440  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1441 
1442  view->CreateRenderSurface();
1443 }

◆ TEST() [70/158]

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

Definition at line 263 of file flutter_windows_view_unittests.cc.

263  {
264  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
265 
266  test_response = false;
267 
268  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
269  std::make_unique<NiceMock<MockWindowBindingHandler>>());
270 
271  view->OnKey(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
272  [](bool handled) {});
273 
274  EXPECT_EQ(key_event_logs.size(), 2);
275  EXPECT_EQ(key_event_logs[0], kKeyEventFromEmbedder);
276  EXPECT_EQ(key_event_logs[1], kKeyEventFromChannel);
277 
278  key_event_logs.clear();
279 }

References kScanCodeKeyA, and kVirtualKeyA.

◆ TEST() [71/158]

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

Definition at line 598 of file flutter_windows_view_unittests.cc.

598  {
599  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
600  EngineModifier modifier(engine.get());
601  modifier.embedder_api().UpdateSemanticsEnabled =
602  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
603  return kSuccess;
604  };
605 
606  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
607  std::make_unique<NiceMock<MockWindowBindingHandler>>());
608 
609  // Enable semantics to instantiate accessibility bridge.
610  view->OnUpdateSemanticsEnabled(true);
611 
612  auto bridge = view->accessibility_bridge().lock();
613  ASSERT_TRUE(bridge);
614 
615  // Add root node.
616  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
617  std::vector<int32_t> node1_children{2};
618  node1.child_count = node1_children.size();
619  node1.children_in_traversal_order = node1_children.data();
620  node1.children_in_hit_test_order = node1_children.data();
621 
622  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
623  node2.label = "prefecture";
624  node2.value = "Kyoto";
625 
626  bridge->AddFlutterSemanticsNodeUpdate(node1);
627  bridge->AddFlutterSemanticsNodeUpdate(node2);
628  bridge->CommitUpdates();
629 
630  // Look up the root windows node delegate.
631  auto root_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
632  ASSERT_TRUE(root_delegate);
633  EXPECT_EQ(root_delegate->GetChildCount(), 1);
634 
635  // Look up the child node delegate
636  auto child_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
637  ASSERT_TRUE(child_delegate);
638  EXPECT_EQ(child_delegate->GetChildCount(), 0);
639 
640  // Ensure a node with ID 0 does not exist.
641  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
642  ASSERT_FALSE(fake_delegate);
643 
644  // Get the root's native IAccessible object.
645  IAccessible* node1_accessible = root_delegate->GetNativeViewAccessible();
646  ASSERT_TRUE(node1_accessible != nullptr);
647 
648  // Property lookups will be made against this node itself.
649  VARIANT varchild{};
650  varchild.vt = VT_I4;
651  varchild.lVal = CHILDID_SELF;
652 
653  // Verify node type is a group.
654  VARIANT varrole{};
655  varrole.vt = VT_I4;
656  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
657  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
658 
659  // Verify child count.
660  long node1_child_count = 0;
661  ASSERT_EQ(node1_accessible->get_accChildCount(&node1_child_count), S_OK);
662  EXPECT_EQ(node1_child_count, 1);
663 
664  {
665  // Look up first child of node1 (node0), a static text node.
666  varchild.lVal = 1;
667  IDispatch* node2_dispatch = nullptr;
668  ASSERT_EQ(node1_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
669  ASSERT_TRUE(node2_dispatch != nullptr);
670  IAccessible* node2_accessible = nullptr;
671  ASSERT_EQ(node2_dispatch->QueryInterface(
672  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
673  S_OK);
674  ASSERT_TRUE(node2_accessible != nullptr);
675 
676  // Verify node name matches our label.
677  varchild.lVal = CHILDID_SELF;
678  BSTR bname = nullptr;
679  ASSERT_EQ(node2_accessible->get_accName(varchild, &bname), S_OK);
680  std::string name(_com_util::ConvertBSTRToString(bname));
681  EXPECT_EQ(name, "prefecture");
682 
683  // Verify node value matches.
684  BSTR bvalue = nullptr;
685  ASSERT_EQ(node2_accessible->get_accValue(varchild, &bvalue), S_OK);
686  std::string value(_com_util::ConvertBSTRToString(bvalue));
687  EXPECT_EQ(value, "Kyoto");
688 
689  // Verify node type is static text.
690  VARIANT varrole{};
691  varrole.vt = VT_I4;
692  ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
693  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
694 
695  // Verify the parent node is the root.
696  IDispatch* parent_dispatch;
697  node2_accessible->get_accParent(&parent_dispatch);
698  IAccessible* parent_accessible;
699  ASSERT_EQ(
700  parent_dispatch->QueryInterface(
701  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
702  S_OK);
703  EXPECT_EQ(parent_accessible, node1_accessible);
704  }
705 }

◆ TEST() [72/158]

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

Definition at line 238 of file flutter_windows_view_unittests.cc.

238  {
239  auto engine = std::make_unique<MockFlutterWindowsEngine>();
240  auto window_binding_handler =
241  std::make_unique<NiceMock<MockWindowBindingHandler>>();
242  auto egl_manager = std::make_unique<egl::MockManager>();
243  auto surface = std::make_unique<egl::MockWindowSurface>();
244  auto surface_ptr = surface.get();
245 
246  EngineModifier modifier{engine.get()};
247  modifier.SetEGLManager(std::move(egl_manager));
248 
249  {
250  std::unique_ptr<FlutterWindowsView> view =
251  engine->CreateView(std::move(window_binding_handler));
252 
253  ViewModifier view_modifier{view.get()};
254  view_modifier.SetSurface(std::move(surface));
255 
256  // The engine must be stopped before the surface can be destroyed.
257  InSequence s;
258  EXPECT_CALL(*engine.get(), Stop).Times(1);
259  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
260  }
261 }

◆ TEST() [73/158]

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

Definition at line 134 of file flutter_windows_view_unittests.cc.

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

◆ TEST() [74/158]

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

Definition at line 1196 of file flutter_windows_view_unittests.cc.

1196  {
1197  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1198  EngineModifier modifier(engine.get());
1199  modifier.embedder_api().UpdateSemanticsEnabled =
1200  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1201  return kSuccess;
1202  };
1203 
1204  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1205  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1206 
1207  // Enable semantics to instantiate accessibility bridge.
1208  view->OnUpdateSemanticsEnabled(true);
1209 
1210  auto bridge = view->accessibility_bridge().lock();
1211  ASSERT_TRUE(bridge);
1212 
1213  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1214  root.id = 0;
1215  root.label = "root";
1216  root.hint = "";
1217  root.value = "";
1218  root.increased_value = "";
1219  root.decreased_value = "";
1220  root.child_count = 0;
1221  root.custom_accessibility_actions_count = 0;
1222  root.flags = static_cast<FlutterSemanticsFlag>(
1223  FlutterSemanticsFlag::kFlutterSemanticsFlagHasToggledState |
1224  FlutterSemanticsFlag::kFlutterSemanticsFlagIsToggled);
1225  bridge->AddFlutterSemanticsNodeUpdate(root);
1226 
1227  bridge->CommitUpdates();
1228 
1229  {
1230  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1231  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
1232  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1233  ax::mojom::CheckedState::kTrue);
1234 
1235  // Get the IAccessible for the root node.
1236  IAccessible* native_view = root_node->GetNativeViewAccessible();
1237  ASSERT_TRUE(native_view != nullptr);
1238 
1239  // Look up against the node itself (not one of its children).
1240  VARIANT varchild = {};
1241  varchild.vt = VT_I4;
1242 
1243  varchild.lVal = CHILDID_SELF;
1244  VARIANT varrole = {};
1245 
1246  // Verify the role of the switch is CHECKBUTTON
1247  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
1248  ASSERT_EQ(varrole.lVal, ROLE_SYSTEM_CHECKBUTTON);
1249 
1250  // Verify the switch is pressed.
1251  VARIANT native_state = {};
1252  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1253  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_PRESSED);
1254  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
1255 
1256  // Test similarly on UIA node.
1257  IRawElementProviderSimple* uia_node;
1258  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1259  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
1260  S_OK);
1261  EXPECT_EQ(varrole.lVal, UIA_ButtonControlTypeId);
1262  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1263  &native_state),
1264  S_OK);
1265  EXPECT_EQ(native_state.lVal, ToggleState_On);
1266  ASSERT_EQ(
1267  uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1268  S_OK);
1269  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=true"), nullptr);
1270  }
1271 
1272  // Test unpressed too.
1273  root.flags = static_cast<FlutterSemanticsFlag>(
1274  FlutterSemanticsFlag::kFlutterSemanticsFlagHasToggledState);
1275  bridge->AddFlutterSemanticsNodeUpdate(root);
1276  bridge->CommitUpdates();
1277 
1278  {
1279  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1280  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
1281  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1282  ax::mojom::CheckedState::kFalse);
1283 
1284  // Get the IAccessible for the root node.
1285  IAccessible* native_view = root_node->GetNativeViewAccessible();
1286  ASSERT_TRUE(native_view != nullptr);
1287 
1288  // Look up against the node itself (not one of its children).
1289  VARIANT varchild = {};
1290  varchild.vt = VT_I4;
1291 
1292  // Verify the switch is not pressed.
1293  varchild.lVal = CHILDID_SELF;
1294  VARIANT native_state = {};
1295  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1296  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_PRESSED);
1297  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
1298 
1299  // Test similarly on UIA node.
1300  IRawElementProviderSimple* uia_node;
1301  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1302  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1303  &native_state),
1304  S_OK);
1305  EXPECT_EQ(native_state.lVal, ToggleState_Off);
1306  ASSERT_EQ(
1307  uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1308  S_OK);
1309  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=false"), nullptr);
1310  }
1311 }

◆ TEST() [75/158]

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

Definition at line 874 of file flutter_windows_view_unittests.cc.

874  {
875  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
876  std::unique_ptr<FlutterWindowsEngine> engine =
877  GetTestEngine(windows_proc_table);
878  EngineModifier engine_modifier{engine.get()};
879 
880  auto egl_manager = std::make_unique<egl::MockManager>();
881  auto surface = std::make_unique<egl::MockWindowSurface>();
882  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
883  auto resized_surface_ptr = resized_surface.get();
884 
885  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
886  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
887 
888  EXPECT_CALL(*egl_manager.get(),
889  CreateWindowSurface(_, /*width=*/500, /*height=*/500))
890  .WillOnce(Return(std::move((resized_surface))));
891  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
892  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
893  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
894 
895  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
896 
897  fml::AutoResetWaitableEvent metrics_sent_latch;
898  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
899  SendWindowMetricsEvent,
900  ([&metrics_sent_latch](auto engine,
901  const FlutterWindowMetricsEvent* event) {
902  metrics_sent_latch.Signal();
903  return kSuccess;
904  }));
905 
906  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
907  std::make_unique<NiceMock<MockWindowBindingHandler>>());
908 
909  ViewModifier view_modifier{view.get()};
910  engine_modifier.SetEGLManager(std::move(egl_manager));
911  view_modifier.SetSurface(std::move(surface));
912 
913  fml::AutoResetWaitableEvent resized_latch;
914  std::thread([&resized_latch, &view]() {
915  // Start the window resize. This sends the new window metrics
916  // and then blocks until another thread completes the window resize.
917  EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
918  resized_latch.Signal();
919  }).detach();
920 
921  // Wait until the platform thread has started the window resize.
922  metrics_sent_latch.Wait();
923 
924  // Complete the window resize by reporting an empty frame.
925  view->OnEmptyFrameGenerated();
926  view->OnFramePresented();
927  resized_latch.Wait();
928 }

◆ TEST() [76/158]

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

Definition at line 1313 of file flutter_windows_view_unittests.cc.

1313  {
1314  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1315  EngineModifier modifier(engine.get());
1316  modifier.embedder_api().UpdateSemanticsEnabled =
1317  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1318  return kSuccess;
1319  };
1320 
1321  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1322  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1323 
1324  // Enable semantics to instantiate accessibility bridge.
1325  view->OnUpdateSemanticsEnabled(true);
1326 
1327  auto bridge = view->accessibility_bridge().lock();
1328  ASSERT_TRUE(bridge);
1329 
1330  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1331  root.id = 0;
1332  root.label = "root";
1333  root.hint = "";
1334  root.value = "";
1335  root.increased_value = "";
1336  root.decreased_value = "";
1337  root.tooltip = "tooltip";
1338  root.child_count = 0;
1339  root.custom_accessibility_actions_count = 0;
1340  root.flags = static_cast<FlutterSemanticsFlag>(
1341  FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField);
1342  bridge->AddFlutterSemanticsNodeUpdate(root);
1343 
1344  bridge->CommitUpdates();
1345  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1346  std::string tooltip = root_node->GetData().GetStringAttribute(
1347  ax::mojom::StringAttribute::kTooltip);
1348  EXPECT_EQ(tooltip, "tooltip");
1349 
1350  // Check that MSAA name contains the tooltip.
1351  IAccessible* native_view = bridge->GetFlutterPlatformNodeDelegateFromID(0)
1352  .lock()
1353  ->GetNativeViewAccessible();
1354  VARIANT varchild = {.vt = VT_I4, .lVal = CHILDID_SELF};
1355  BSTR bname;
1356  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
1357  EXPECT_NE(std::wcsstr(bname, L"tooltip"), nullptr);
1358 
1359  // Check that UIA help text is equal to the tooltip.
1360  IRawElementProviderSimple* uia_node;
1361  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1362  VARIANT varname{};
1363  ASSERT_EQ(uia_node->GetPropertyValue(UIA_HelpTextPropertyId, &varname), S_OK);
1364  std::string uia_tooltip = _com_util::ConvertBSTRToString(varname.bstrVal);
1365  EXPECT_EQ(uia_tooltip, "tooltip");
1366 }

◆ TEST() [77/158]

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

Definition at line 1532 of file flutter_windows_view_unittests.cc.

1532  {
1533  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1534  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1535  auto egl_manager = std::make_unique<egl::MockManager>();
1536  egl::MockContext render_context;
1537  auto surface = std::make_unique<egl::MockWindowSurface>();
1538  auto surface_ptr = surface.get();
1539 
1540  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1541 
1542  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1543  .WillRepeatedly([](fml::closure callback) {
1544  callback();
1545  return true;
1546  });
1547 
1548  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1549  .WillOnce(Return(false))
1550  .WillOnce(Return(true));
1551 
1552  EXPECT_CALL(*egl_manager.get(), render_context)
1553  .WillRepeatedly(Return(&render_context));
1554 
1555  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
1556 
1557  InSequence s;
1558  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1559  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1560  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1561 
1562  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1563  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1564  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1565 
1566  EXPECT_CALL(*engine.get(), Stop).Times(1);
1567  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1568 
1569  EngineModifier engine_modifier{engine.get()};
1570  engine_modifier.SetEGLManager(std::move(egl_manager));
1571 
1572  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1573  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1574  ViewModifier view_modifier{view.get()};
1575  view_modifier.SetSurface(std::move(surface));
1576 
1577  engine->OnDwmCompositionChanged();
1578  engine->OnDwmCompositionChanged();
1579 }

References callback.

◆ TEST() [78/158]

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

Definition at line 1028 of file flutter_windows_view_unittests.cc.

1028  {
1029  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1030  EngineModifier modifier(engine.get());
1031 
1032  FlutterWindowsView view{kImplicitViewId, engine.get(),
1033  std::make_unique<flutter::FlutterWindow>(100, 100)};
1034 
1035  bool schedule_frame_called = false;
1036  modifier.embedder_api().ScheduleFrame =
1037  MOCK_ENGINE_PROC(ScheduleFrame, ([&schedule_frame_called](auto engine) {
1038  schedule_frame_called = true;
1039  return kSuccess;
1040  }));
1041 
1042  view.OnWindowRepaint();
1043  EXPECT_TRUE(schedule_frame_called);
1044 }

References flutter::kImplicitViewId.

◆ TEST() [79/158]

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

Definition at line 973 of file flutter_windows_view_unittests.cc.

973  {
974  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
975  EngineModifier engine_modifier(engine.get());
976 
977  auto egl_manager = std::make_unique<egl::MockManager>();
978  auto surface = std::make_unique<egl::MockWindowSurface>();
979 
980  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
981  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(false));
982  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(false));
983 
984  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
985  std::make_unique<NiceMock<MockWindowBindingHandler>>());
986 
987  ViewModifier view_modifier{view.get()};
988  engine_modifier.SetEGLManager(std::move(egl_manager));
989  view_modifier.SetSurface(std::move(surface));
990 
991  auto metrics_sent = false;
992  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
993  SendWindowMetricsEvent,
994  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
995  metrics_sent = true;
996  return kSuccess;
997  }));
998 
999  view->OnWindowSizeChanged(500, 500);
1000 }

◆ TEST() [80/158]

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

Definition at line 933 of file flutter_windows_view_unittests.cc.

933  {
934  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
935  EngineModifier engine_modifier(engine.get());
936 
937  auto egl_manager = std::make_unique<egl::MockManager>();
938  auto surface = std::make_unique<egl::MockWindowSurface>();
939 
940  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
941  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
942 
943  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
944  std::make_unique<NiceMock<MockWindowBindingHandler>>());
945 
946  ViewModifier view_modifier{view.get()};
947  engine_modifier.SetEGLManager(std::move(egl_manager));
948  view_modifier.SetSurface(std::move(surface));
949 
950  // Begin a frame.
951  ASSERT_TRUE(view->OnFrameGenerated(100, 100));
952 
953  // Inject a window resize between the frame generation and
954  // frame presentation. The new size invalidates the current frame.
955  fml::AutoResetWaitableEvent resized_latch;
956  std::thread([&resized_latch, &view]() {
957  // The resize is never completed. The view times out and returns false.
958  EXPECT_FALSE(view->OnWindowSizeChanged(500, 500));
959  resized_latch.Signal();
960  }).detach();
961 
962  // Wait until the platform thread has started the window resize.
963  resized_latch.Wait();
964 
965  // Complete the invalidated frame while a resize is pending. Although this
966  // might mean that we presented a frame with the wrong size, this should not
967  // crash the app.
968  view->OnFramePresented();
969 }

◆ TEST() [81/158]

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

Definition at line 816 of file flutter_windows_view_unittests.cc.

816  {
817  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
818  std::unique_ptr<FlutterWindowsEngine> engine =
819  GetTestEngine(windows_proc_table);
820  EngineModifier engine_modifier{engine.get()};
821 
822  auto egl_manager = std::make_unique<egl::MockManager>();
823  auto surface = std::make_unique<egl::MockWindowSurface>();
824  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
825  auto resized_surface_ptr = resized_surface.get();
826 
827  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
828  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
829 
830  EXPECT_CALL(*egl_manager.get(),
831  CreateWindowSurface(_, /*width=*/500, /*height=*/500))
832  .WillOnce(Return(std::move((resized_surface))));
833  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
834  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
835  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
836 
837  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
838 
839  engine_modifier.SetEGLManager(std::move(egl_manager));
840 
841  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
842  std::make_unique<NiceMock<MockWindowBindingHandler>>());
843 
844  ViewModifier view_modifier{view.get()};
845  view_modifier.SetSurface(std::move(surface));
846 
847  fml::AutoResetWaitableEvent metrics_sent_latch;
848  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
849  SendWindowMetricsEvent,
850  ([&metrics_sent_latch](auto engine,
851  const FlutterWindowMetricsEvent* event) {
852  metrics_sent_latch.Signal();
853  return kSuccess;
854  }));
855 
856  fml::AutoResetWaitableEvent resized_latch;
857  std::thread([&resized_latch, &view]() {
858  // Start the window resize. This sends the new window metrics
859  // and then blocks until another thread completes the window resize.
860  EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
861  resized_latch.Signal();
862  }).detach();
863 
864  // Wait until the platform thread has started the window resize.
865  metrics_sent_latch.Wait();
866 
867  // Complete the window resize by reporting a frame with the new window size.
868  ASSERT_TRUE(view->OnFrameGenerated(500, 500));
869  view->OnFramePresented();
870  resized_latch.Wait();
871 }

◆ TEST() [82/158]

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

Definition at line 1004 of file flutter_windows_view_unittests.cc.

1004  {
1005  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1006  EngineModifier modifier(engine.get());
1007 
1008  auto egl_manager = std::make_unique<egl::MockManager>();
1009 
1010  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1011 
1012  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
1013  std::make_unique<NiceMock<MockWindowBindingHandler>>());
1014 
1015  modifier.SetEGLManager(std::move(egl_manager));
1016 
1017  auto metrics_sent = false;
1018  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1019  SendWindowMetricsEvent,
1020  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1021  metrics_sent = true;
1022  return kSuccess;
1023  }));
1024 
1025  view->OnWindowSizeChanged(500, 500);
1026 }

◆ TEST() [83/158]

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 }

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

◆ TEST() [84/158]

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

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

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

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

Definition at line 764 of file keyboard_key_embedder_handler_unittests.cc.

764  {
765  TestKeystate key_state;
766  std::vector<TestFlutterKeyEvent> results;
767  TestFlutterKeyEvent* event;
768  bool last_handled = false;
769 
770  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
771  std::make_unique<KeyboardKeyEmbedderHandler>(
772  [&results](const FlutterKeyEvent& event,
773  FlutterKeyEventCallback callback, void* user_data) {
774  results.emplace_back(event, callback, user_data);
775  },
776  key_state.Getter(), DefaultMapVkToScan);
777  last_handled = false;
778 
779  key_state.Set(kVirtualKeyA, true);
780 
781  // Press A (with was_down true)
782  handler->KeyboardHook(
783  kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
784  [&last_handled](bool handled) { last_handled = handled; });
785  EXPECT_EQ(last_handled, false);
786  EXPECT_EQ(results.size(), 1);
787  event = &results[0];
788  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
789  EXPECT_EQ(event->physical, kPhysicalKeyA);
790  EXPECT_EQ(event->logical, kLogicalKeyA);
791  EXPECT_STREQ(event->character, "a");
792  EXPECT_EQ(event->synthesized, false);
793 
794  event->callback(true, event->user_data);
795  EXPECT_EQ(last_handled, true);
796  results.clear();
797 
798  // Release A
799  last_handled = false;
800  key_state.Set(kVirtualKeyA, false);
801  handler->KeyboardHook(
802  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 'a', false, true,
803  [&last_handled](bool handled) { last_handled = handled; });
804  EXPECT_EQ(last_handled, false);
805  EXPECT_EQ(results.size(), 1);
806  event = &results[0];
807  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
808  EXPECT_EQ(event->physical, kPhysicalKeyA);
809  EXPECT_EQ(event->logical, kLogicalKeyA);
810  EXPECT_STREQ(event->character, "");
811  EXPECT_EQ(event->synthesized, false);
812 
813  event->callback(true, event->user_data);
814  EXPECT_EQ(last_handled, true);
815  results.clear();
816 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [88/158]

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

Definition at line 818 of file keyboard_key_embedder_handler_unittests.cc.

818  {
819  TestKeystate key_state;
820  std::vector<TestFlutterKeyEvent> results;
821  TestFlutterKeyEvent* event;
822  bool last_handled = false;
823 
824  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
825  std::make_unique<KeyboardKeyEmbedderHandler>(
826  [&results](const FlutterKeyEvent& event,
827  FlutterKeyEventCallback callback, void* user_data) {
828  results.emplace_back(event, callback, user_data);
829  },
830  key_state.Getter(), DefaultMapVkToScan);
831  last_handled = false;
832 
833  // KeyA's key down is missed.
834 
835  key_state.Set(kVirtualKeyA, true);
836 
837  // Press A again (should yield an empty event)
838  last_handled = false;
839  handler->KeyboardHook(
840  kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 'a', false, true,
841  [&last_handled](bool handled) { last_handled = handled; });
842  EXPECT_EQ(last_handled, true);
843  EXPECT_EQ(results.size(), 1);
844  event = &results[0];
845  EXPECT_EQ(event->physical, 0);
846  EXPECT_EQ(event->logical, 0);
847  EXPECT_EQ(event->callback, nullptr);
848  results.clear();
849 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [89/158]

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

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 }

References flutter::ConvertChar32ToUtf8().

◆ TEST() [91/158]

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 }

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

◆ TEST() [92/158]

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

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

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

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

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 yield an empty event)
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, true);
756  EXPECT_EQ(results.size(), 1);
757  event = &results[0];
758  EXPECT_EQ(event->physical, 0);
759  EXPECT_EQ(event->logical, 0);
760  EXPECT_EQ(event->callback, nullptr);
761  results.clear();
762 }

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [97/158]

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

Definition at line 851 of file keyboard_key_embedder_handler_unittests.cc.

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

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [98/158]

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

Definition at line 939 of file keyboard_key_embedder_handler_unittests.cc.

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

References callback, kScanCodeKeyA, kVirtualKeyA, and user_data.

◆ TEST() [99/158]

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

Definition at line 1119 of file keyboard_key_embedder_handler_unittests.cc.

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

References callback, and user_data.

◆ TEST() [100/158]

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

Definition at line 1059 of file keyboard_key_embedder_handler_unittests.cc.

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

References callback, and user_data.

◆ TEST() [101/158]

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

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

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

Definition at line 1177 of file keyboard_key_embedder_handler_unittests.cc.

1177  {
1178  TestKeystate key_state;
1179  std::vector<TestFlutterKeyEvent> results;
1180  TestFlutterKeyEvent* event;
1181  bool last_handled = false;
1182 
1183  // The app starts with NumLock toggled on
1184  key_state.Set(VK_NUMLOCK, false, true);
1185 
1186  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
1187  std::make_unique<KeyboardKeyEmbedderHandler>(
1188  [&results](const FlutterKeyEvent& event,
1189  FlutterKeyEventCallback callback, void* user_data) {
1190  results.emplace_back(event, callback, user_data);
1191  },
1192  key_state.Getter(), DefaultMapVkToScan);
1193 
1194  // NumLock key down
1195  key_state.Set(VK_NUMLOCK, true, false);
1196  handler->KeyboardHook(
1197  VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
1198  [&last_handled](bool handled) { last_handled = handled; });
1199  EXPECT_EQ(last_handled, false);
1200  EXPECT_EQ(results.size(), 1);
1201  event = &results[0];
1202  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1203  EXPECT_EQ(event->physical, kPhysicalNumLock);
1204  EXPECT_EQ(event->logical, kLogicalNumLock);
1205  EXPECT_STREQ(event->character, "");
1206  EXPECT_EQ(event->synthesized, false);
1207 
1208  event->callback(true, event->user_data);
1209  EXPECT_EQ(last_handled, true);
1210  results.clear();
1211 }

References callback, and user_data.

◆ TEST() [104/158]

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

Definition at line 1213 of file keyboard_key_embedder_handler_unittests.cc.

1213  {
1214  TestKeystate key_state;
1215  std::vector<TestFlutterKeyEvent> results;
1216  TestFlutterKeyEvent* event;
1217  bool last_handled = false;
1218 
1219  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
1220  std::make_unique<KeyboardKeyEmbedderHandler>(
1221  [&results](const FlutterKeyEvent& event,
1222  FlutterKeyEventCallback callback, void* user_data) {
1223  results.emplace_back(event, callback, user_data);
1224  },
1225  key_state.Getter(), DefaultMapVkToScan);
1226 
1227  // Press KeyAltLeft.
1228  key_state.Set(VK_LMENU, true);
1229  handler->KeyboardHook(
1230  VK_LMENU, kScanCodeAltLeft, WM_SYSKEYDOWN, 0, false, false,
1231  [&last_handled](bool handled) { last_handled = handled; });
1232  EXPECT_EQ(last_handled, false);
1233  EXPECT_EQ(results.size(), 1);
1234  event = results.data();
1235  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1236  EXPECT_EQ(event->physical, kPhysicalAltLeft);
1237  EXPECT_EQ(event->logical, kLogicalAltLeft);
1238  EXPECT_STREQ(event->character, "");
1239  EXPECT_EQ(event->synthesized, false);
1240 
1241  event->callback(true, event->user_data);
1242  EXPECT_EQ(last_handled, true);
1243  results.clear();
1244 
1245  // Release KeyAltLeft.
1246  key_state.Set(VK_LMENU, false);
1247  handler->KeyboardHook(
1248  VK_LMENU, kScanCodeAltLeft, WM_SYSKEYUP, 0, false, true,
1249  [&last_handled](bool handled) { last_handled = handled; });
1250  EXPECT_EQ(results.size(), 1);
1251  event = results.data();
1252  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1253  EXPECT_EQ(event->physical, kPhysicalAltLeft);
1254  EXPECT_EQ(event->logical, kLogicalAltLeft);
1255  EXPECT_STREQ(event->character, "");
1256  EXPECT_EQ(event->synthesized, false);
1257  event->callback(false, event->user_data);
1258 }

References callback, and user_data.

◆ TEST() [105/158]

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

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 }

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

◆ TEST() [107/158]

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

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 }

References hook_history, and message.

◆ TEST() [109/158]

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

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 }

References flutter::EncodeUtf16().

◆ TEST() [111/158]

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

Definition at line 23 of file window_unittests.cc.

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

◆ TEST() [112/158]

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

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

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

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

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 }

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

◆ TEST() [117/158]

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

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

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

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

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

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

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

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

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

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 }

References type.

◆ TEST() [127/158]

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

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

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

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

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

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

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

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

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

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

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

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 }

References flutter::GetPreferredLanguageInfo().

◆ TEST() [139/158]

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 }

References flutter::GetPreferredLanguages().

◆ TEST() [140/158]

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 }

References flutter::GetUserTimeFormat().

◆ TEST() [141/158]

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 }

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

◆ TEST() [142/158]

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

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

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

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

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

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 }

References flutter::Prefer24HourTime().

◆ TEST() [148/158]

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

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

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

Definition at line 68 of file task_runner_unittests.cc.

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

◆ TEST() [151/158]

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

Definition at line 45 of file task_runner_unittests.cc.

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

◆ TEST() [152/158]

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

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

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

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

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

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

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

Definition at line 54 of file flutter_windows_unittests.cc.

54  {
55  FlutterDesktopEngineProperties properties = {};
56  properties.assets_path = L"";
57  properties.icu_data_path = L"icudtl.dat";
58  auto engine = FlutterDesktopEngineCreate(&properties);
59  ASSERT_NE(engine, nullptr);
60  auto texture_registrar = FlutterDesktopEngineGetTextureRegistrar(engine);
61  EXPECT_NE(texture_registrar, nullptr);
62  FlutterDesktopEngineDestroy(engine);
63 }

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

◆ TEST_F() [1/155]

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

Definition at line 128 of file compositor_opengl_unittests.cc.

128  {
129  UseHeadlessEngine();
130 
131  auto compositor = CompositorOpenGL{engine(), kMockResolver};
132 
133  FlutterBackingStoreConfig config = {};
134  FlutterBackingStore backing_store = {};
135 
136  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
137  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
138  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
139 }

◆ TEST_F() [2/155]

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

Definition at line 191 of file compositor_opengl_unittests.cc.

191  {
192  UseHeadlessEngine();
193 
194  auto compositor = CompositorOpenGL{engine(), kMockResolver};
195 
196  FlutterBackingStoreConfig config = {};
197  FlutterBackingStore backing_store = {};
198 
199  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
200  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
201 
202  FlutterLayer layer = {};
203  layer.type = kFlutterLayerContentTypeBackingStore;
204  layer.backing_store = &backing_store;
205  const FlutterLayer* layer_ptr = &layer;
206 
207  EXPECT_FALSE(compositor.Present(kImplicitViewId, &layer_ptr, 1));
208 
209  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
210 }

References flutter::kImplicitViewId.

◆ TEST_F() [3/155]

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

Definition at line 141 of file compositor_opengl_unittests.cc.

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

◆ TEST_F() [4/155]

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

Definition at line 237 of file compositor_opengl_unittests.cc.

237  {
238  UseEngineWithView(/*add_surface = */ false);
239 
240  auto compositor = CompositorOpenGL{engine(), kMockResolver};
241 
242  FlutterBackingStoreConfig config = {};
243  FlutterBackingStore backing_store = {};
244 
245  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
246  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
247 
248  FlutterLayer layer = {};
249  layer.type = kFlutterLayerContentTypeBackingStore;
250  layer.backing_store = &backing_store;
251  const FlutterLayer* layer_ptr = &layer;
252 
253  EXPECT_FALSE(compositor.Present(view()->view_id(), &layer_ptr, 1));
254 
255  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
256 }

◆ TEST_F() [5/155]

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

Definition at line 153 of file compositor_opengl_unittests.cc.

153  {
154  UseEngineWithView();
155 
156  auto compositor = CompositorOpenGL{engine(), kMockResolver};
157 
158  FlutterBackingStoreConfig config = {};
159  FlutterBackingStore backing_store = {};
160 
161  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
162  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
163 
164  FlutterLayer layer = {};
165  layer.type = kFlutterLayerContentTypeBackingStore;
166  layer.backing_store = &backing_store;
167  const FlutterLayer* layer_ptr = &layer;
168 
169  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
170  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
171  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
172  EXPECT_TRUE(compositor.Present(view()->view_id(), &layer_ptr, 1));
173 
174  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
175 }

◆ TEST_F() [6/155]

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

Definition at line 177 of file compositor_opengl_unittests.cc.

177  {
178  UseEngineWithView();
179 
180  auto compositor = CompositorOpenGL{engine(), kMockResolver};
181 
182  // The context will be bound twice: first to initialize the compositor, second
183  // to clear the surface.
184  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
185  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
186  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
187  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
188  EXPECT_TRUE(compositor.Present(view()->view_id(), nullptr, 0));
189 }

◆ TEST_F() [7/155]

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

Definition at line 212 of file compositor_opengl_unittests.cc.

212  {
213  UseEngineWithView();
214 
215  auto compositor = CompositorOpenGL{engine(), kMockResolver};
216 
217  FlutterBackingStoreConfig config = {};
218  FlutterBackingStore backing_store = {};
219 
220  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
221  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
222 
223  FlutterLayer layer = {};
224  layer.type = kFlutterLayerContentTypeBackingStore;
225  layer.backing_store = &backing_store;
226  const FlutterLayer* layer_ptr = &layer;
227 
228  FlutterViewId unknown_view_id = 123;
229  ASSERT_NE(view()->view_id(), unknown_view_id);
230  ASSERT_EQ(engine()->view(unknown_view_id), nullptr);
231 
232  EXPECT_FALSE(compositor.Present(unknown_view_id, &layer_ptr, 1));
233 
234  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
235 }

◆ TEST_F() [8/155]

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

Definition at line 79 of file compositor_software_unittests.cc.

79  {
80  UseHeadlessEngine();
81 
82  auto compositor = CompositorSoftware{engine()};
83 
84  FlutterBackingStoreConfig config = {};
85  FlutterBackingStore backing_store = {};
86 
87  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
88  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
89 }

◆ TEST_F() [9/155]

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

Definition at line 145 of file compositor_software_unittests.cc.

145  {
146  UseHeadlessEngine();
147 
148  auto compositor = CompositorSoftware{engine()};
149 
150  FlutterBackingStoreConfig config = {};
151  FlutterBackingStore backing_store = {};
152 
153  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
154 
155  FlutterLayer layer = {};
156  layer.type = kFlutterLayerContentTypeBackingStore;
157  layer.backing_store = &backing_store;
158  const FlutterLayer* layer_ptr = &layer;
159 
160  EXPECT_FALSE(compositor.Present(kImplicitViewId, &layer_ptr, 1));
161 
162  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
163 }

References flutter::kImplicitViewId.

◆ TEST_F() [10/155]

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

Definition at line 91 of file compositor_software_unittests.cc.

91  {
92  UseEngineWithView();
93 
94  auto compositor = CompositorSoftware{engine()};
95 
96  FlutterBackingStoreConfig config = {};
97  FlutterBackingStore backing_store = {};
98 
99  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
100 
101  FlutterLayer layer = {};
102  layer.type = kFlutterLayerContentTypeBackingStore;
103  layer.backing_store = &backing_store;
104  const FlutterLayer* layer_ptr = &layer;
105 
106  EXPECT_CALL(*view(), PresentSoftwareBitmap).WillOnce(Return(true));
107  EXPECT_TRUE(compositor.Present(view()->view_id(), &layer_ptr, 1));
108 
109  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
110 }

◆ TEST_F() [11/155]

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

Definition at line 112 of file compositor_software_unittests.cc.

112  {
113  UseEngineWithView();
114 
115  auto compositor = CompositorSoftware{engine()};
116 
117  EXPECT_CALL(*view(), ClearSoftwareBitmap).WillOnce(Return(true));
118  EXPECT_TRUE(compositor.Present(view()->view_id(), nullptr, 0));
119 }

◆ TEST_F() [12/155]

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

Definition at line 121 of file compositor_software_unittests.cc.

121  {
122  UseEngineWithView();
123 
124  auto compositor = CompositorSoftware{engine()};
125 
126  FlutterBackingStoreConfig config = {};
127  FlutterBackingStore backing_store = {};
128 
129  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
130 
131  FlutterLayer layer = {};
132  layer.type = kFlutterLayerContentTypeBackingStore;
133  layer.backing_store = &backing_store;
134  const FlutterLayer* layer_ptr = &layer;
135 
136  FlutterViewId unknown_view_id = 123;
137  ASSERT_NE(view()->view_id(), unknown_view_id);
138  ASSERT_EQ(engine()->view(unknown_view_id), nullptr);
139 
140  EXPECT_FALSE(compositor.Present(unknown_view_id, &layer_ptr, 1));
141 
142  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
143 }

◆ TEST_F() [13/155]

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

Definition at line 97 of file cursor_handler_unittests.cc.

97  {
98  UseEngineWithView();
99 
100  TestBinaryMessenger messenger;
101  CursorHandler cursor_handler(&messenger, engine());
102 
103  EXPECT_CALL(*window(), UpdateFlutterCursor("click")).Times(1);
104 
105  bool success = false;
106  MethodResultFunctions<> result_handler(
107  [&success](const EncodableValue* result) {
108  success = true;
109  EXPECT_EQ(result, nullptr);
110  },
111  nullptr, nullptr);
112 
113  SimulateCursorMessage(&messenger, kActivateSystemCursorMethod,
114  std::make_unique<EncodableValue>(EncodableMap{
115  {EncodableValue("device"), EncodableValue(0)},
116  {EncodableValue("kind"), EncodableValue("click")},
117  }),
118  &result_handler);
119 
120  EXPECT_TRUE(success);
121 }

References kActivateSystemCursorMethod.

◆ TEST_F() [14/155]

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

Definition at line 123 of file cursor_handler_unittests.cc.

123  {
124  UseHeadlessEngine();
125 
126  TestBinaryMessenger messenger;
127  CursorHandler cursor_handler(&messenger, engine());
128 
129  bool error = false;
130  MethodResultFunctions<> result_handler(
131  nullptr,
132  [&error](const std::string& error_code, const std::string& error_message,
133  const EncodableValue* value) {
134  error = true;
135  EXPECT_EQ(error_message,
136  "Cursor is not available in Windows headless mode");
137  },
138  nullptr);
139 
140  SimulateCursorMessage(&messenger, kActivateSystemCursorMethod,
141  std::make_unique<EncodableValue>(EncodableMap{
142  {EncodableValue("device"), EncodableValue(0)},
143  {EncodableValue("kind"), EncodableValue("click")},
144  }),
145  &result_handler);
146 
147  EXPECT_TRUE(error);
148 }

References kActivateSystemCursorMethod.

◆ TEST_F() [15/155]

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

Definition at line 150 of file cursor_handler_unittests.cc.

150  {
151  UseEngineWithView();
152 
153  TestBinaryMessenger messenger;
154  CursorHandler cursor_handler(&messenger, engine());
155 
156  // Create a 4x4 raw BGRA test cursor buffer.
157  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
158 
159  bool success = false;
160  MethodResultFunctions<> result_handler(
161  [&success](const EncodableValue* result) {
162  success = true;
163  EXPECT_EQ(std::get<std::string>(*result), "hello");
164  },
165  nullptr, nullptr);
166 
167  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
168  std::make_unique<EncodableValue>(EncodableMap{
169  {EncodableValue("name"), EncodableValue("hello")},
170  {EncodableValue("buffer"), EncodableValue(buffer)},
171  {EncodableValue("width"), EncodableValue(4)},
172  {EncodableValue("height"), EncodableValue(4)},
173  {EncodableValue("hotX"), EncodableValue(0.0)},
174  {EncodableValue("hotY"), EncodableValue(0.0)},
175  }),
176  &result_handler);
177 
178  EXPECT_TRUE(success);
179 }

References kCreateCustomCursorMethod.

◆ TEST_F() [16/155]

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

Definition at line 291 of file cursor_handler_unittests.cc.

291  {
292  UseEngineWithView();
293 
294  TestBinaryMessenger messenger;
295  CursorHandler cursor_handler(&messenger, engine());
296 
297  // Create a 4x4 raw BGRA test cursor buffer.
298  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
299 
300  bool success = false;
301  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
302  MethodResultFunctions<> delete_result_handler(
303  [&success](const EncodableValue* result) {
304  success = true;
305  EXPECT_EQ(result, nullptr);
306  },
307  nullptr, nullptr);
308 
309  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
310  std::make_unique<EncodableValue>(EncodableMap{
311  {EncodableValue("name"), EncodableValue("hello")},
312  {EncodableValue("buffer"), EncodableValue(buffer)},
313  {EncodableValue("width"), EncodableValue(4)},
314  {EncodableValue("height"), EncodableValue(4)},
315  {EncodableValue("hotX"), EncodableValue(0.0)},
316  {EncodableValue("hotY"), EncodableValue(0.0)},
317  }),
318  &create_result_handler);
319 
320  SimulateCursorMessage(&messenger, kDeleteCustomCursorMethod,
321  std::make_unique<EncodableValue>(EncodableMap{
322  {EncodableValue("name"), EncodableValue("hello")},
323  }),
324  &delete_result_handler);
325 
326  EXPECT_TRUE(success);
327 }

References kCreateCustomCursorMethod, and kDeleteCustomCursorMethod.

◆ TEST_F() [17/155]

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

Definition at line 329 of file cursor_handler_unittests.cc.

329  {
330  UseEngineWithView();
331 
332  TestBinaryMessenger messenger;
333  CursorHandler cursor_handler(&messenger, engine());
334 
335  bool success = false;
336  MethodResultFunctions<> result_handler(
337  [&success](const EncodableValue* result) {
338  success = true;
339  EXPECT_EQ(result, nullptr);
340  },
341  nullptr, nullptr);
342 
343  SimulateCursorMessage(&messenger, kDeleteCustomCursorMethod,
344  std::make_unique<EncodableValue>(EncodableMap{
345  {EncodableValue("name"), EncodableValue("fake")},
346  }),
347  &result_handler);
348 
349  EXPECT_TRUE(success);
350 }

References kDeleteCustomCursorMethod.

◆ TEST_F() [18/155]

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

Definition at line 181 of file cursor_handler_unittests.cc.

181  {
182  UseEngineWithView();
183 
184  TestBinaryMessenger messenger;
185  CursorHandler cursor_handler(&messenger, engine());
186 
187  // Create a 4x4 raw BGRA test cursor buffer.
188  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
189 
190  bool success = false;
191  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
192  MethodResultFunctions<> set_result_handler(
193  [&success](const EncodableValue* result) {
194  success = true;
195  EXPECT_EQ(result, nullptr);
196  },
197  nullptr, nullptr);
198 
199  EXPECT_CALL(*window(), SetFlutterCursor(/*cursor=*/NotNull())).Times(1);
200 
201  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
202  std::make_unique<EncodableValue>(EncodableMap{
203  {EncodableValue("name"), EncodableValue("hello")},
204  {EncodableValue("buffer"), EncodableValue(buffer)},
205  {EncodableValue("width"), EncodableValue(4)},
206  {EncodableValue("height"), EncodableValue(4)},
207  {EncodableValue("hotX"), EncodableValue(0.0)},
208  {EncodableValue("hotY"), EncodableValue(0.0)},
209  }),
210  &create_result_handler);
211 
212  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
213  std::make_unique<EncodableValue>(EncodableMap{
214  {EncodableValue("name"), EncodableValue("hello")},
215  }),
216  &set_result_handler);
217 
218  EXPECT_TRUE(success);
219 }

References kCreateCustomCursorMethod, and kSetCustomCursorMethod.

◆ TEST_F() [19/155]

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

Definition at line 221 of file cursor_handler_unittests.cc.

221  {
222  UseHeadlessEngine();
223 
224  TestBinaryMessenger messenger;
225  CursorHandler cursor_handler(&messenger, engine());
226 
227  // Create a 4x4 raw BGRA test cursor buffer.
228  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
229 
230  bool error = false;
231  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
232  MethodResultFunctions<> set_result_handler(
233  nullptr,
234  [&error](const std::string& error_code, const std::string& error_message,
235  const EncodableValue* value) {
236  error = true;
237  EXPECT_EQ(error_message,
238  "Cursor is not available in Windows headless mode");
239  },
240  nullptr);
241 
242  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
243  std::make_unique<EncodableValue>(EncodableMap{
244  {EncodableValue("name"), EncodableValue("hello")},
245  {EncodableValue("buffer"), EncodableValue(buffer)},
246  {EncodableValue("width"), EncodableValue(4)},
247  {EncodableValue("height"), EncodableValue(4)},
248  {EncodableValue("hotX"), EncodableValue(0.0)},
249  {EncodableValue("hotY"), EncodableValue(0.0)},
250  }),
251  &create_result_handler);
252 
253  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
254  std::make_unique<EncodableValue>(EncodableMap{
255  {EncodableValue("name"), EncodableValue("hello")},
256  }),
257  &set_result_handler);
258 
259  EXPECT_TRUE(error);
260 }

References kCreateCustomCursorMethod, and kSetCustomCursorMethod.

◆ TEST_F() [20/155]

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

Definition at line 262 of file cursor_handler_unittests.cc.

262  {
263  UseEngineWithView();
264 
265  TestBinaryMessenger messenger;
266  CursorHandler cursor_handler(&messenger, engine());
267 
268  bool error = false;
269  MethodResultFunctions<> result_handler(
270  nullptr,
271  [&error](const std::string& error_code, const std::string& error_message,
272  const EncodableValue* value) {
273  error = true;
274  EXPECT_EQ(
275  error_message,
276  "The custom cursor identified by the argument key cannot be found");
277  },
278  nullptr);
279 
280  EXPECT_CALL(*window(), SetFlutterCursor).Times(0);
281 
282  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
283  std::make_unique<EncodableValue>(EncodableMap{
284  {EncodableValue("name"), EncodableValue("hello")},
285  }),
286  &result_handler);
287 
288  EXPECT_TRUE(error);
289 }

References kSetCustomCursorMethod.

◆ TEST_F() [21/155]

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

Definition at line 657 of file flutter_windows_engine_unittests.cc.

657  {
658  auto& context = GetContext();
659  WindowsConfigBuilder builder{context};
660  builder.SetDartEntrypoint("sendAccessibilityAnnouncement");
661 
662  bool done = false;
663  auto native_entry =
664  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
665  context.AddNativeFunction("Signal", native_entry);
666 
667  EnginePtr engine{builder.RunHeadless()};
668  ASSERT_NE(engine, nullptr);
669 
670  ui::AXPlatformNodeDelegateBase parent_delegate;
671  AlertPlatformNodeDelegate delegate{parent_delegate};
672 
673  auto window_binding_handler =
674  std::make_unique<NiceMock<MockWindowBindingHandler>>();
675  EXPECT_CALL(*window_binding_handler, GetAlertDelegate)
676  .WillOnce(Return(&delegate));
677 
678  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
679  MockFlutterWindowsView view{windows_engine,
680  std::move(window_binding_handler)};
681  EngineModifier modifier{windows_engine};
682  modifier.SetImplicitView(&view);
683 
684  windows_engine->UpdateSemanticsEnabled(true);
685 
686  EXPECT_CALL(view, NotifyWinEventWrapper).Times(1);
687 
688  // Rely on timeout mechanism in CI.
689  while (!done) {
690  windows_engine->task_runner()->ProcessTasks();
691  }
692 }

References flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [22/155]

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

Definition at line 695 of file flutter_windows_engine_unittests.cc.

695  {
696  auto& context = GetContext();
697  WindowsConfigBuilder builder{context};
698  builder.SetDartEntrypoint("sendAccessibilityAnnouncement");
699 
700  bool done = false;
701  auto native_entry =
702  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
703  context.AddNativeFunction("Signal", native_entry);
704 
705  EnginePtr engine{builder.RunHeadless()};
706  ASSERT_NE(engine, nullptr);
707 
708  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
709  windows_engine->UpdateSemanticsEnabled(true);
710 
711  // Rely on timeout mechanism in CI.
712  while (!done) {
713  windows_engine->task_runner()->ProcessTasks();
714  }
715 }

References flutter::FlutterWindowsEngine::UpdateSemanticsEnabled().

◆ TEST_F() [23/155]

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

Definition at line 719 of file flutter_windows_engine_unittests.cc.

719  {
720  fml::testing::LogCapture log_capture;
721 
722  auto& context = GetContext();
723  WindowsConfigBuilder builder{context};
724  builder.SetDartEntrypoint("sendAccessibilityTooltipEvent");
725 
726  bool done = false;
727  auto native_entry =
728  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
729  context.AddNativeFunction("Signal", native_entry);
730 
731  ViewControllerPtr controller{builder.Run()};
732  ASSERT_NE(controller, nullptr);
733 
734  auto engine = FlutterDesktopViewControllerGetEngine(controller.get());
735  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine);
736  windows_engine->UpdateSemanticsEnabled(true);
737 
738  // Rely on timeout mechanism in CI.
739  while (!done) {
740  windows_engine->task_runner()->ProcessTasks();
741  }
742 
743  // Verify no error was logged.
744  // Regression test for:
745  // https://github.com/flutter/flutter/issues/144274
746  EXPECT_EQ(log_capture.str().find("tooltip"), std::string::npos);
747 }

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

◆ TEST_F() [24/155]

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

Definition at line 510 of file flutter_windows_engine_unittests.cc.

510  {
511  FlutterWindowsEngineBuilder builder{GetContext()};
512  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
513  EngineModifier modifier(engine.get());
514 
515  MockEmbedderApiForKeyboard(modifier,
516  std::make_shared<MockKeyResponseController>());
517 
518  engine->Run();
519 
520  // Verify that destruction handlers don't overwrite each other.
521  int result1 = 0;
522  int result2 = 0;
523  engine->AddPluginRegistrarDestructionCallback(
524  [](FlutterDesktopPluginRegistrarRef ref) {
525  auto result = reinterpret_cast<int*>(ref);
526  *result = 1;
527  },
528  reinterpret_cast<FlutterDesktopPluginRegistrarRef>(&result1));
529  engine->AddPluginRegistrarDestructionCallback(
530  [](FlutterDesktopPluginRegistrarRef ref) {
531  auto result = reinterpret_cast<int*>(ref);
532  *result = 2;
533  },
534  reinterpret_cast<FlutterDesktopPluginRegistrarRef>(&result2));
535 
536  engine->Stop();
537  EXPECT_EQ(result1, 1);
538  EXPECT_EQ(result2, 2);
539 }

◆ TEST_F() [25/155]

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

Definition at line 992 of file flutter_windows_engine_unittests.cc.

992  {
993  FlutterWindowsEngineBuilder builder{GetContext()};
994 
995  auto engine = builder.Build();
996  auto window_binding_handler =
997  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
998  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
999 
1000  EngineModifier modifier(engine.get());
1001  modifier.SetImplicitView(&view);
1002  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1003  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1004  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(false));
1005  modifier.SetLifecycleManager(std::move(handler));
1006  engine->lifecycle_manager()->BeginProcessingExit();
1007 
1008  engine->lifecycle_manager()->ExternalWindowMessage(0, WM_CLOSE, 0, 0);
1009 }

◆ TEST_F() [26/155]

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

Definition at line 1011 of file flutter_windows_engine_unittests.cc.

1011  {
1012  FlutterWindowsEngineBuilder builder{GetContext()};
1013 
1014  auto engine = builder.Build();
1015  auto window_binding_handler =
1016  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1017  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1018 
1019  EngineModifier modifier(engine.get());
1020  modifier.SetImplicitView(&view);
1021  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1022  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1023  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed))
1024  .Times(1);
1025  modifier.SetLifecycleManager(std::move(handler));
1026  engine->Run();
1027 }

References flutter::kResumed.

◆ TEST_F() [27/155]

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

Definition at line 1217 of file flutter_windows_engine_unittests.cc.

1217  {
1218  FlutterWindowsEngineBuilder builder{GetContext()};
1219  builder.SetDartEntrypoint("enableLifecycleToFrom");
1220 
1221  auto engine = builder.Build();
1222  auto window_binding_handler =
1223  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1224  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1225 
1226  EngineModifier modifier(engine.get());
1227  modifier.SetImplicitView(&view);
1228  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1229 
1230  bool lifecycle_began = false;
1231  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1232  EXPECT_CALL(*handler, SetLifecycleState).Times(1);
1233  handler->begin_processing_callback = [&]() { lifecycle_began = true; };
1234  modifier.SetLifecycleManager(std::move(handler));
1235 
1236  engine->Run();
1237 
1238  while (!lifecycle_began) {
1239  engine->task_runner()->ProcessTasks();
1240  }
1241 }

◆ TEST_F() [28/155]

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

Definition at line 167 of file flutter_windows_engine_unittests.cc.

167  {
168  FlutterWindowsEngineBuilder builder{GetContext()};
169  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
170  EngineModifier modifier(engine.get());
171  bool on_vsync_called = false;
172 
173  modifier.embedder_api().GetCurrentTime =
174  MOCK_ENGINE_PROC(GetCurrentTime, ([]() -> uint64_t { return 1; }));
175  modifier.embedder_api().OnVsync = MOCK_ENGINE_PROC(
176  OnVsync,
177  ([&on_vsync_called, engine_instance = engine.get()](
178  FLUTTER_API_SYMBOL(FlutterEngine) engine, intptr_t baton,
179  uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos) {
180  EXPECT_EQ(baton, 1);
181  EXPECT_EQ(frame_start_time_nanos, 16600000);
182  EXPECT_EQ(frame_target_time_nanos, 33200000);
183  on_vsync_called = true;
184  return kSuccess;
185  }));
186  modifier.SetStartTime(0);
187  modifier.SetFrameInterval(16600000);
188 
189  engine->OnVsync(1);
190 
191  EXPECT_TRUE(on_vsync_called);
192 }

◆ TEST_F() [29/155]

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

Definition at line 464 of file flutter_windows_engine_unittests.cc.

464  {
465  FlutterWindowsEngineBuilder builder{GetContext()};
466  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
467  EngineModifier modifier(engine.get());
468 
469  bool called = false;
470  std::string message = "Hello";
471  modifier.embedder_api().DispatchSemanticsAction = MOCK_ENGINE_PROC(
472  DispatchSemanticsAction,
473  ([&called, &message](auto engine, auto target, auto action, auto data,
474  auto data_length) {
475  called = true;
476  EXPECT_EQ(target, 42);
477  EXPECT_EQ(action, kFlutterSemanticsActionDismiss);
478  EXPECT_EQ(memcmp(data, message.c_str(), message.size()), 0);
479  EXPECT_EQ(data_length, message.size());
480  return kSuccess;
481  }));
482 
483  auto data = fml::MallocMapping::Copy(message.c_str(), message.size());
484  engine->DispatchSemanticsAction(42, kFlutterSemanticsActionDismiss,
485  std::move(data));
486  EXPECT_TRUE(called);
487 }

References action, and message.

◆ TEST_F() [30/155]

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

Definition at line 972 of file flutter_windows_engine_unittests.cc.

972  {
973  FlutterWindowsEngineBuilder builder{GetContext()};
974 
975  auto engine = builder.Build();
976  auto window_binding_handler =
977  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
978  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
979 
980  EngineModifier modifier(engine.get());
981  modifier.SetImplicitView(&view);
982  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
983  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
984  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(false));
985  modifier.SetLifecycleManager(std::move(handler));
986  engine->lifecycle_manager()->BeginProcessingExit();
987 
988  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
989  0);
990 }

◆ TEST_F() [31/155]

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

Definition at line 1116 of file flutter_windows_engine_unittests.cc.

1116  {
1117  FlutterWindowsEngineBuilder builder{GetContext()};
1118  builder.SetDartEntrypoint("enableLifecycleTest");
1119  bool finished = false;
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, SetLifecycleState)
1131  .WillRepeatedly([handler_ptr = handler.get()](AppLifecycleState state) {
1132  handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1133  });
1134  modifier.SetLifecycleManager(std::move(handler));
1135 
1136  auto binary_messenger =
1137  std::make_unique<BinaryMessengerImpl>(engine->messenger());
1138  // Mark the test only as completed on receiving an inactive state message.
1139  binary_messenger->SetMessageHandler(
1140  "flutter/unittest", [&finished](const uint8_t* message,
1141  size_t message_size, BinaryReply reply) {
1142  std::string contents(message, message + message_size);
1143  EXPECT_NE(contents.find("AppLifecycleState.inactive"),
1144  std::string::npos);
1145  finished = true;
1146  char response[] = "";
1147  reply(reinterpret_cast<uint8_t*>(response), 0);
1148  });
1149 
1150  engine->Run();
1151 
1152  // Test that setting the state before enabling lifecycle does nothing.
1153  HWND hwnd = reinterpret_cast<HWND>(1);
1154  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
1155  view.OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
1156  EXPECT_FALSE(finished);
1157 
1158  // Test that we can set the state afterwards.
1159 
1160  engine->lifecycle_manager()->BeginProcessingLifecycle();
1161  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
1162 
1163  while (!finished) {
1164  engine->task_runner()->ProcessTasks();
1165  }
1166 }

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

◆ TEST_F() [32/155]

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

Definition at line 1058 of file flutter_windows_engine_unittests.cc.

1058  {
1059  FlutterWindowsEngineBuilder builder{GetContext()};
1060 
1061  auto engine = builder.Build();
1062  auto window_binding_handler =
1063  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1064  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1065 
1066  EngineModifier modifier(engine.get());
1067  modifier.SetImplicitView(&view);
1068  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1069  // Sets lifecycle state to resumed.
1070  engine->Run();
1071 
1072  // Ensure HWND(1) is in the set of visible windows before hiding it.
1073  engine->ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), WM_SHOWWINDOW,
1074  TRUE, NULL);
1075  engine->ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), WM_SHOWWINDOW,
1076  FALSE, NULL);
1077 
1078  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1079  AppLifecycleState::kHidden);
1080 }

References flutter::kHidden.

◆ TEST_F() [33/155]

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

Definition at line 573 of file flutter_windows_engine_unittests.cc.

573  {
574  FlutterWindowsEngineBuilder builder{GetContext()};
575  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
576  EXPECT_EQ(engine->GetExecutableName(), "flutter_windows_unittests.exe");
577 }

◆ TEST_F() [34/155]

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

Definition at line 1082 of file flutter_windows_engine_unittests.cc.

1082  {
1083  FlutterWindowsEngineBuilder builder{GetContext()};
1084  HWND outer = reinterpret_cast<HWND>(1);
1085  HWND inner = reinterpret_cast<HWND>(2);
1086 
1087  auto engine = builder.Build();
1088  auto window_binding_handler =
1089  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1090  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1091  ON_CALL(view, GetWindowHandle).WillByDefault([=]() { return inner; });
1092 
1093  EngineModifier modifier(engine.get());
1094  modifier.SetImplicitView(&view);
1095  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1096  // Sets lifecycle state to resumed.
1097  engine->Run();
1098 
1099  // Show both top-level and Flutter window.
1100  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1101  outer, WM_SHOWWINDOW, TRUE, NULL);
1102  view.OnWindowStateEvent(inner, WindowStateEvent::kShow);
1103  view.OnWindowStateEvent(inner, WindowStateEvent::kFocus);
1104 
1105  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1106  AppLifecycleState::kResumed);
1107 
1108  // Hide Flutter window, but not top level window.
1109  view.OnWindowStateEvent(inner, WindowStateEvent::kHide);
1110 
1111  // The top-level window is still visible, so we ought not enter hidden state.
1112  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1113  AppLifecycleState::kInactive);
1114 }

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

◆ TEST_F() [35/155]

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

Definition at line 953 of file flutter_windows_engine_unittests.cc.

953  {
954  FlutterWindowsEngineBuilder builder{GetContext()};
955 
956  auto engine = builder.Build();
957  auto window_binding_handler =
958  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
959  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
960 
961  EngineModifier modifier(engine.get());
962  modifier.SetImplicitView(&view);
963  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
964  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
965  EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(0);
966  modifier.SetLifecycleManager(std::move(handler));
967 
968  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
969  0);
970 }

◆ TEST_F() [36/155]

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

Definition at line 1168 of file flutter_windows_engine_unittests.cc.

1168  {
1169  FlutterWindowsEngineBuilder builder{GetContext()};
1170  builder.SetDartEntrypoint("enableLifecycleToFrom");
1171  bool enabled_lifecycle = false;
1172  bool dart_responded = false;
1173 
1174  auto engine = builder.Build();
1175  auto window_binding_handler =
1176  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1177  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1178 
1179  EngineModifier modifier(engine.get());
1180  modifier.SetImplicitView(&view);
1181  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1182  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1183  EXPECT_CALL(*handler, SetLifecycleState)
1184  .WillRepeatedly([handler_ptr = handler.get()](AppLifecycleState state) {
1185  handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1186  });
1187  handler->begin_processing_callback = [&]() { enabled_lifecycle = true; };
1188  modifier.SetLifecycleManager(std::move(handler));
1189 
1190  auto binary_messenger =
1191  std::make_unique<BinaryMessengerImpl>(engine->messenger());
1192  binary_messenger->SetMessageHandler(
1193  "flutter/unittest",
1194  [&](const uint8_t* message, size_t message_size, BinaryReply reply) {
1195  std::string contents(message, message + message_size);
1196  EXPECT_NE(contents.find("AppLifecycleState."), std::string::npos);
1197  dart_responded = true;
1198  char response[] = "";
1199  reply(reinterpret_cast<uint8_t*>(response), 0);
1200  });
1201 
1202  engine->Run();
1203 
1204  while (!enabled_lifecycle) {
1205  engine->task_runner()->ProcessTasks();
1206  }
1207 
1208  HWND hwnd = reinterpret_cast<HWND>(1);
1209  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
1210  view.OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
1211 
1212  while (!dart_responded) {
1213  engine->task_runner()->ProcessTasks();
1214  }
1215 }

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

◆ TEST_F() [37/155]

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

Definition at line 1029 of file flutter_windows_engine_unittests.cc.

1029  {
1030  FlutterWindowsEngineBuilder builder{GetContext()};
1031 
1032  auto engine = builder.Build();
1033  auto window_binding_handler =
1034  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1035  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1036 
1037  EngineModifier modifier(engine.get());
1038  modifier.SetImplicitView(&view);
1039  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1040  engine->Run();
1041 
1042  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1043  (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
1044  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1045  AppLifecycleState::kResumed);
1046 
1047  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1048  (HWND)1, WM_SIZE, SIZE_MINIMIZED, 0);
1049  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1050  AppLifecycleState::kHidden);
1051 
1052  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
1053  (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
1054  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
1055  AppLifecycleState::kInactive);
1056 }

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

◆ TEST_F() [38/155]

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

Definition at line 354 of file flutter_windows_engine_unittests.cc.

354  {
355  FlutterWindowsEngineBuilder builder{GetContext()};
356  builder.SetDartEntrypoint("hiPlatformChannels");
357 
358  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
359 
360  EngineModifier modifier(engine.get());
361  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
362 
363  auto binary_messenger =
364  std::make_unique<BinaryMessengerImpl>(engine->messenger());
365 
366  engine->Run();
367  bool did_call_callback = false;
368  bool did_call_reply = false;
369  bool did_call_dart_reply = false;
370  std::string channel = "hi";
371  std::unique_ptr<std::thread> reply_thread;
372  binary_messenger->SetMessageHandler(
373  channel,
374  [&did_call_callback, &did_call_dart_reply, &reply_thread](
375  const uint8_t* message, size_t message_size, BinaryReply reply) {
376  if (message_size == 5) {
377  EXPECT_EQ(message[0], static_cast<uint8_t>('h'));
378  reply_thread.reset(new std::thread([reply = std::move(reply)]() {
379  char response[] = {'b', 'y', 'e'};
380  reply(reinterpret_cast<uint8_t*>(response), 3);
381  }));
382  did_call_callback = true;
383  } else {
384  EXPECT_EQ(message_size, 3);
385  EXPECT_EQ(message[0], static_cast<uint8_t>('b'));
386  did_call_dart_reply = true;
387  }
388  });
389  char payload[] = {'h', 'e', 'l', 'l', 'o'};
390  binary_messenger->Send(
391  channel, reinterpret_cast<uint8_t*>(payload), 5,
392  [&did_call_reply](const uint8_t* reply, size_t reply_size) {
393  EXPECT_EQ(reply_size, 5);
394  EXPECT_EQ(reply[0], static_cast<uint8_t>('h'));
395  did_call_reply = true;
396  });
397  // Rely on timeout mechanism in CI.
398  while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
399  engine->task_runner()->ProcessTasks();
400  }
401  ASSERT_TRUE(reply_thread);
402  reply_thread->join();
403 }

References message.

◆ TEST_F() [39/155]

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

Definition at line 309 of file flutter_windows_engine_unittests.cc.

309  {
310  FlutterWindowsEngineBuilder builder{GetContext()};
311  builder.SetDartEntrypoint("hiPlatformChannels");
312 
313  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
314  EngineModifier modifier(engine.get());
315  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
316 
317  auto binary_messenger =
318  std::make_unique<BinaryMessengerImpl>(engine->messenger());
319 
320  engine->Run();
321  bool did_call_callback = false;
322  bool did_call_reply = false;
323  bool did_call_dart_reply = false;
324  std::string channel = "hi";
325  binary_messenger->SetMessageHandler(
326  channel,
327  [&did_call_callback, &did_call_dart_reply](
328  const uint8_t* message, size_t message_size, BinaryReply reply) {
329  if (message_size == 5) {
330  EXPECT_EQ(message[0], static_cast<uint8_t>('h'));
331  char response[] = {'b', 'y', 'e'};
332  reply(reinterpret_cast<uint8_t*>(response), 3);
333  did_call_callback = true;
334  } else {
335  EXPECT_EQ(message_size, 3);
336  EXPECT_EQ(message[0], static_cast<uint8_t>('b'));
337  did_call_dart_reply = true;
338  }
339  });
340  char payload[] = {'h', 'e', 'l', 'l', 'o'};
341  binary_messenger->Send(
342  channel, reinterpret_cast<uint8_t*>(payload), 5,
343  [&did_call_reply](const uint8_t* reply, size_t reply_size) {
344  EXPECT_EQ(reply_size, 5);
345  EXPECT_EQ(reply[0], static_cast<uint8_t>('h'));
346  did_call_reply = true;
347  });
348  // Rely on timeout mechanism in CI.
349  while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
350  engine->task_runner()->ProcessTasks();
351  }
352 }

References message.

◆ TEST_F() [40/155]

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

Definition at line 622 of file flutter_windows_engine_unittests.cc.

622  {
623  FlutterWindowsEngineBuilder builder{GetContext()};
624  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
625  EngineModifier modifier(engine.get());
626 
627  modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
628  PostRenderThreadTask, ([](auto engine, auto callback, auto context) {
629  callback(context);
630  return kSuccess;
631  }));
632 
633  bool called = false;
634  engine->PostRasterThreadTask([&called]() { called = true; });
635 
636  EXPECT_TRUE(called);
637 }

References callback.

◆ TEST_F() [41/155]

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

Definition at line 1243 of file flutter_windows_engine_unittests.cc.

1243  {
1244  FlutterWindowsEngineBuilder builder{GetContext()};
1245  builder.SetDartEntrypoint("sendCreatePlatformViewMethod");
1246  auto engine = builder.Build();
1247 
1248  EngineModifier modifier{engine.get()};
1249  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
1250 
1251  bool received_call = false;
1252 
1253  auto manager = std::make_unique<MockPlatformViewManager>(engine.get());
1254  EXPECT_CALL(*manager, AddPlatformView)
1255  .WillOnce([&](PlatformViewId id, std::string_view type_name) {
1256  received_call = true;
1257  return true;
1258  });
1259  modifier.SetPlatformViewPlugin(std::move(manager));
1260 
1261  engine->Run();
1262 
1263  while (!received_call) {
1264  engine->task_runner()->ProcessTasks();
1265  }
1266 }

◆ TEST_F() [42/155]

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

Definition at line 51 of file flutter_windows_engine_unittests.cc.

51  {
52  FlutterWindowsEngineBuilder builder{GetContext()};
53  builder.AddDartEntrypointArgument("arg1");
54  builder.AddDartEntrypointArgument("arg2");
55 
56  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
57  EngineModifier modifier(engine.get());
58 
59  // The engine should be run with expected configuration values.
60  bool run_called = false;
61  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
62  Run, ([&run_called, engine_instance = engine.get()](
63  size_t version, const FlutterRendererConfig* config,
64  const FlutterProjectArgs* args, void* user_data,
65  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
66  run_called = true;
67  *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
68 
69  EXPECT_EQ(version, FLUTTER_ENGINE_VERSION);
70  EXPECT_NE(config, nullptr);
71  // We have an EGL manager, so this should be using OpenGL.
72  EXPECT_EQ(config->type, kOpenGL);
73  EXPECT_EQ(user_data, engine_instance);
74  // Spot-check arguments.
75  EXPECT_NE(args->assets_path, nullptr);
76  EXPECT_NE(args->icu_data_path, nullptr);
77  EXPECT_EQ(args->dart_entrypoint_argc, 2U);
78  EXPECT_EQ(strcmp(args->dart_entrypoint_argv[0], "arg1"), 0);
79  EXPECT_EQ(strcmp(args->dart_entrypoint_argv[1], "arg2"), 0);
80  EXPECT_NE(args->platform_message_callback, nullptr);
81  EXPECT_NE(args->custom_task_runners, nullptr);
82  EXPECT_NE(args->custom_task_runners->thread_priority_setter, nullptr);
83  EXPECT_EQ(args->custom_dart_entrypoint, nullptr);
84  EXPECT_NE(args->vsync_callback, nullptr);
85  EXPECT_EQ(args->update_semantics_callback, nullptr);
86  EXPECT_NE(args->update_semantics_callback2, nullptr);
87  EXPECT_EQ(args->update_semantics_node_callback, nullptr);
88  EXPECT_EQ(args->update_semantics_custom_action_callback, nullptr);
89 
90  args->custom_task_runners->thread_priority_setter(
91  FlutterThreadPriority::kRaster);
92  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
93  THREAD_PRIORITY_ABOVE_NORMAL);
94  return kSuccess;
95  }));
96  // Accessibility updates must do nothing when the embedder engine is mocked
97  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
98  UpdateAccessibilityFeatures,
99  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
100  FlutterAccessibilityFeature flags) { return kSuccess; });
101 
102  // It should send locale info.
103  bool update_locales_called = false;
104  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
105  UpdateLocales,
106  ([&update_locales_called](auto engine, const FlutterLocale** locales,
107  size_t locales_count) {
108  update_locales_called = true;
109 
110  EXPECT_GT(locales_count, 0);
111  EXPECT_NE(locales, nullptr);
112 
113  return kSuccess;
114  }));
115 
116  // And it should send initial settings info.
117  bool settings_message_sent = false;
118  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
119  SendPlatformMessage,
120  ([&settings_message_sent](auto engine, auto message) {
121  if (std::string(message->channel) == std::string("flutter/settings")) {
122  settings_message_sent = true;
123  }
124 
125  return kSuccess;
126  }));
127 
128  // And it should send display info.
129  bool notify_display_update_called = false;
130  modifier.SetFrameInterval(16600000); // 60 fps.
131  modifier.embedder_api().NotifyDisplayUpdate = MOCK_ENGINE_PROC(
132  NotifyDisplayUpdate,
133  ([&notify_display_update_called, engine_instance = engine.get()](
134  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
135  const FlutterEngineDisplaysUpdateType update_type,
136  const FlutterEngineDisplay* embedder_displays,
137  size_t display_count) {
138  EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
139  EXPECT_EQ(display_count, 1);
140 
141  FlutterEngineDisplay display = embedder_displays[0];
142 
143  EXPECT_EQ(display.display_id, 0);
144  EXPECT_EQ(display.single_display, true);
145  EXPECT_EQ(std::floor(display.refresh_rate), 60.0);
146 
147  notify_display_update_called = true;
148  return kSuccess;
149  }));
150 
151  // Set the EGL manager to !nullptr to test ANGLE rendering.
152  modifier.SetEGLManager(std::make_unique<egl::MockManager>());
153 
154  engine->Run();
155 
156  EXPECT_TRUE(run_called);
157  EXPECT_TRUE(update_locales_called);
158  EXPECT_TRUE(settings_message_sent);
159  EXPECT_TRUE(notify_display_update_called);
160 
161  // Ensure that deallocation doesn't call the actual Shutdown with the bogus
162  // engine pointer that the overridden Run returned.
163  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
164  modifier.ReleaseEGLManager();
165 }

References message, flutter::FlutterEngine::Run(), and user_data.

◆ TEST_F() [43/155]

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

Definition at line 39 of file flutter_windows_engine_unittests.cc.

39  {
40  FlutterWindowsEngineBuilder builder{GetContext()};
41  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
42 
43  EngineModifier modifier(engine.get());
44  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
45 
46  ASSERT_TRUE(engine->Run());
47  ASSERT_EQ(engine->view(kImplicitViewId), nullptr);
48  ASSERT_EQ(engine->view(123), nullptr);
49 }

References flutter::kImplicitViewId.

◆ TEST_F() [44/155]

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

Definition at line 247 of file flutter_windows_engine_unittests.cc.

247  {
248  FlutterWindowsEngineBuilder builder{GetContext()};
249  builder.SetSwitches({"--enable-impeller=true"});
250  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
251  EngineModifier modifier(engine.get());
252 
253  modifier.embedder_api().NotifyDisplayUpdate =
254  MOCK_ENGINE_PROC(NotifyDisplayUpdate,
255  ([engine_instance = engine.get()](
256  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
257  const FlutterEngineDisplaysUpdateType update_type,
258  const FlutterEngineDisplay* embedder_displays,
259  size_t display_count) { return kSuccess; }));
260 
261  // Accessibility updates must do nothing when the embedder engine is mocked
262  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
263  UpdateAccessibilityFeatures,
264  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
265  FlutterAccessibilityFeature flags) { return kSuccess; });
266 
267  // Stub out UpdateLocales and SendPlatformMessage as we don't have a fully
268  // initialized engine instance.
269  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
270  UpdateLocales, ([](auto engine, const FlutterLocale** locales,
271  size_t locales_count) { return kSuccess; }));
272  modifier.embedder_api().SendPlatformMessage =
273  MOCK_ENGINE_PROC(SendPlatformMessage,
274  ([](auto engine, auto message) { return kSuccess; }));
275 
276  // Set the EGL manager to nullptr to test software fallback path.
277  modifier.SetEGLManager(nullptr);
278 
279  EXPECT_FALSE(engine->Run());
280 }

References message, and flutter::FlutterEngine::Run().

◆ TEST_F() [45/155]

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

Definition at line 194 of file flutter_windows_engine_unittests.cc.

194  {
195  FlutterWindowsEngineBuilder builder{GetContext()};
196  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
197  EngineModifier modifier(engine.get());
198 
199  modifier.embedder_api().NotifyDisplayUpdate =
200  MOCK_ENGINE_PROC(NotifyDisplayUpdate,
201  ([engine_instance = engine.get()](
202  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
203  const FlutterEngineDisplaysUpdateType update_type,
204  const FlutterEngineDisplay* embedder_displays,
205  size_t display_count) { return kSuccess; }));
206 
207  // The engine should be run with expected configuration values.
208  bool run_called = false;
209  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
210  Run, ([&run_called, engine_instance = engine.get()](
211  size_t version, const FlutterRendererConfig* config,
212  const FlutterProjectArgs* args, void* user_data,
213  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
214  run_called = true;
215  *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
216  // We don't have an EGL Manager, so we should be using software.
217  EXPECT_EQ(config->type, kSoftware);
218  return kSuccess;
219  }));
220  // Accessibility updates must do nothing when the embedder engine is mocked
221  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
222  UpdateAccessibilityFeatures,
223  [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
224  FlutterAccessibilityFeature flags) { return kSuccess; });
225 
226  // Stub out UpdateLocales and SendPlatformMessage as we don't have a fully
227  // initialized engine instance.
228  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
229  UpdateLocales, ([](auto engine, const FlutterLocale** locales,
230  size_t locales_count) { return kSuccess; }));
231  modifier.embedder_api().SendPlatformMessage =
232  MOCK_ENGINE_PROC(SendPlatformMessage,
233  ([](auto engine, auto message) { return kSuccess; }));
234 
235  // Set the EGL manager to nullptr to test software fallback path.
236  modifier.SetEGLManager(nullptr);
237 
238  engine->Run();
239 
240  EXPECT_TRUE(run_called);
241 
242  // Ensure that deallocation doesn't call the actual Shutdown with the bogus
243  // engine pointer that the overridden Run returned.
244  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
245 }

References message, flutter::FlutterEngine::Run(), and user_data.

◆ TEST_F() [46/155]

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

Definition at line 541 of file flutter_windows_engine_unittests.cc.

541  {
542  FlutterWindowsEngineBuilder builder{GetContext()};
543  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
544  EngineModifier modifier(engine.get());
545 
546  bool called = false;
547  modifier.embedder_api().ScheduleFrame =
548  MOCK_ENGINE_PROC(ScheduleFrame, ([&called](auto engine) {
549  called = true;
550  return kSuccess;
551  }));
552 
553  engine->ScheduleFrame();
554  EXPECT_TRUE(called);
555 }

◆ TEST_F() [47/155]

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

Definition at line 282 of file flutter_windows_engine_unittests.cc.

282  {
283  FlutterWindowsEngineBuilder builder{GetContext()};
284  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
285  EngineModifier modifier(engine.get());
286 
287  const char* channel = "test";
288  const std::vector<uint8_t> test_message = {1, 2, 3, 4};
289 
290  // Without a response, SendPlatformMessage should be a simple pass-through.
291  bool called = false;
292  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
293  SendPlatformMessage, ([&called, test_message](auto engine, auto message) {
294  called = true;
295  EXPECT_STREQ(message->channel, "test");
296  EXPECT_EQ(message->message_size, test_message.size());
297  EXPECT_EQ(memcmp(message->message, test_message.data(),
298  message->message_size),
299  0);
300  EXPECT_EQ(message->response_handle, nullptr);
301  return kSuccess;
302  }));
303 
304  engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
305  nullptr, nullptr);
306  EXPECT_TRUE(called);
307 }

References message.

◆ TEST_F() [48/155]

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

Definition at line 405 of file flutter_windows_engine_unittests.cc.

405  {
406  FlutterWindowsEngineBuilder builder{GetContext()};
407  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
408  EngineModifier modifier(engine.get());
409 
410  const char* channel = "test";
411  const std::vector<uint8_t> test_message = {1, 2, 3, 4};
412  auto* dummy_response_handle =
413  reinterpret_cast<FlutterPlatformMessageResponseHandle*>(5);
414  const FlutterDesktopBinaryReply reply_handler = [](auto... args) {};
415  void* reply_user_data = reinterpret_cast<void*>(6);
416 
417  // When a response is requested, a handle should be created, passed as part
418  // of the message, and then released.
419  bool create_response_handle_called = false;
420  modifier.embedder_api().PlatformMessageCreateResponseHandle =
421  MOCK_ENGINE_PROC(
422  PlatformMessageCreateResponseHandle,
423  ([&create_response_handle_called, &reply_handler, reply_user_data,
424  dummy_response_handle](auto engine, auto reply, auto user_data,
425  auto response_handle) {
426  create_response_handle_called = true;
427  EXPECT_EQ(reply, reply_handler);
428  EXPECT_EQ(user_data, reply_user_data);
429  EXPECT_NE(response_handle, nullptr);
430  *response_handle = dummy_response_handle;
431  return kSuccess;
432  }));
433  bool release_response_handle_called = false;
434  modifier.embedder_api().PlatformMessageReleaseResponseHandle =
435  MOCK_ENGINE_PROC(
436  PlatformMessageReleaseResponseHandle,
437  ([&release_response_handle_called, dummy_response_handle](
438  auto engine, auto response_handle) {
439  release_response_handle_called = true;
440  EXPECT_EQ(response_handle, dummy_response_handle);
441  return kSuccess;
442  }));
443  bool send_message_called = false;
444  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
445  SendPlatformMessage, ([&send_message_called, test_message,
446  dummy_response_handle](auto engine, auto message) {
447  send_message_called = true;
448  EXPECT_STREQ(message->channel, "test");
449  EXPECT_EQ(message->message_size, test_message.size());
450  EXPECT_EQ(memcmp(message->message, test_message.data(),
451  message->message_size),
452  0);
453  EXPECT_EQ(message->response_handle, dummy_response_handle);
454  return kSuccess;
455  }));
456 
457  engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
458  reply_handler, reply_user_data);
459  EXPECT_TRUE(create_response_handle_called);
460  EXPECT_TRUE(release_response_handle_called);
461  EXPECT_TRUE(send_message_called);
462 }

References message, and user_data.

◆ TEST_F() [49/155]

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

Definition at line 557 of file flutter_windows_engine_unittests.cc.

557  {
558  FlutterWindowsEngineBuilder builder{GetContext()};
559  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
560  EngineModifier modifier(engine.get());
561 
562  bool called = false;
563  modifier.embedder_api().SetNextFrameCallback = MOCK_ENGINE_PROC(
564  SetNextFrameCallback, ([&called](auto engine, auto callback, auto data) {
565  called = true;
566  return kSuccess;
567  }));
568 
569  engine->SetNextFrameCallback([]() {});
570  EXPECT_TRUE(called);
571 }

References callback.

◆ TEST_F() [50/155]

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

Definition at line 489 of file flutter_windows_engine_unittests.cc.

489  {
490  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kBackground);
491  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
492  THREAD_PRIORITY_BELOW_NORMAL);
493 
494  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kDisplay);
495  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
496  THREAD_PRIORITY_ABOVE_NORMAL);
497 
498  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kRaster);
499  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
500  THREAD_PRIORITY_ABOVE_NORMAL);
501 
502  // FlutterThreadPriority::kNormal does not change thread priority, reset to 0
503  // here.
504  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
505 
506  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kNormal);
507  EXPECT_EQ(GetThreadPriority(GetCurrentThread()), THREAD_PRIORITY_NORMAL);
508 }

References flutter::WindowsPlatformThreadPrioritySetter().

◆ TEST_F() [51/155]

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

Definition at line 774 of file flutter_windows_engine_unittests.cc.

774  {
775  FlutterWindowsEngineBuilder builder{GetContext()};
776  builder.SetDartEntrypoint("exitTestExit");
777  bool finished = false;
778 
779  auto engine = builder.Build();
780  auto window_binding_handler =
781  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
782  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
783 
784  EngineModifier modifier(engine.get());
785  modifier.SetImplicitView(&view);
786  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
787  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
788  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
789  EXPECT_CALL(*handler, Quit)
790  .WillOnce([&finished](std::optional<HWND> hwnd,
791  std::optional<WPARAM> wparam,
792  std::optional<LPARAM> lparam,
793  UINT exit_code) { finished = exit_code == 0; });
794  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(true));
795  modifier.SetLifecycleManager(std::move(handler));
796 
797  engine->lifecycle_manager()->BeginProcessingExit();
798 
799  engine->Run();
800 
801  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
802  0);
803 
804  // The test will only succeed when this while loop exits. Otherwise it will
805  // timeout.
806  while (!finished) {
807  engine->task_runner()->ProcessTasks();
808  }
809 }

References flutter::kResumed.

◆ TEST_F() [52/155]

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

Definition at line 811 of file flutter_windows_engine_unittests.cc.

811  {
812  FlutterWindowsEngineBuilder builder{GetContext()};
813  builder.SetDartEntrypoint("exitTestCancel");
814  bool did_call = false;
815 
816  auto engine = builder.Build();
817  auto window_binding_handler =
818  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
819  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
820 
821  EngineModifier modifier(engine.get());
822  modifier.SetImplicitView(&view);
823  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
824  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
825  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
826  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(true));
827  EXPECT_CALL(*handler, Quit).Times(0);
828  modifier.SetLifecycleManager(std::move(handler));
829  engine->lifecycle_manager()->BeginProcessingExit();
830 
831  auto binary_messenger =
832  std::make_unique<BinaryMessengerImpl>(engine->messenger());
833  binary_messenger->SetMessageHandler(
834  "flutter/platform", [&did_call](const uint8_t* message,
835  size_t message_size, BinaryReply reply) {
836  std::string contents(message, message + message_size);
837  EXPECT_NE(contents.find("\"method\":\"System.exitApplication\""),
838  std::string::npos);
839  EXPECT_NE(contents.find("\"type\":\"required\""), std::string::npos);
840  EXPECT_NE(contents.find("\"exitCode\":0"), std::string::npos);
841  did_call = true;
842  char response[] = "";
843  reply(reinterpret_cast<uint8_t*>(response), 0);
844  });
845 
846  engine->Run();
847 
848  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
849  0);
850 
851  while (!did_call) {
852  engine->task_runner()->ProcessTasks();
853  }
854 }

References flutter::kResumed, and message.

◆ TEST_F() [53/155]

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

Definition at line 919 of file flutter_windows_engine_unittests.cc.

919  {
920  FlutterWindowsEngineBuilder builder{GetContext()};
921  builder.SetDartEntrypoint("exitTestExit");
922  bool finished = false;
923 
924  auto engine = builder.Build();
925  auto window_binding_handler =
926  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
927  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
928 
929  EngineModifier modifier(engine.get());
930  modifier.SetImplicitView(&view);
931  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
932  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
933  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
934  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce([&finished]() {
935  finished = true;
936  return false;
937  });
938  // Quit should not be called when there is more than one window.
939  EXPECT_CALL(*handler, Quit).Times(0);
940  modifier.SetLifecycleManager(std::move(handler));
941  engine->lifecycle_manager()->BeginProcessingExit();
942 
943  engine->Run();
944 
945  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
946  0);
947 
948  while (!finished) {
949  engine->task_runner()->ProcessTasks();
950  }
951 }

References flutter::kResumed.

◆ TEST_F() [54/155]

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

Definition at line 859 of file flutter_windows_engine_unittests.cc.

859  {
860  FlutterWindowsEngineBuilder builder{GetContext()};
861  builder.SetDartEntrypoint("exitTestExit");
862  bool second_close = false;
863 
864  auto engine = builder.Build();
865  auto window_binding_handler =
866  std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
867  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
868 
869  EngineModifier modifier(engine.get());
870  modifier.SetImplicitView(&view);
871  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
872  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
873  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
874  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(true));
875  EXPECT_CALL(*handler, Quit)
876  .WillOnce([handler_ptr = handler.get()](
877  std::optional<HWND> hwnd, std::optional<WPARAM> wparam,
878  std::optional<LPARAM> lparam, UINT exit_code) {
879  handler_ptr->WindowsLifecycleManager::Quit(hwnd, wparam, lparam,
880  exit_code);
881  });
882  EXPECT_CALL(*handler, DispatchMessage)
883  .WillRepeatedly(
884  [&engine](HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
885  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
886  hwnd, msg, wparam, lparam);
887  });
888  modifier.SetLifecycleManager(std::move(handler));
889  engine->lifecycle_manager()->BeginProcessingExit();
890 
891  engine->Run();
892 
893  // This delegate will be registered after the lifecycle manager, so it will be
894  // called only when a message is not consumed by the lifecycle manager. This
895  // should be called on the second, synthesized WM_CLOSE message that the
896  // lifecycle manager posts.
897  engine->window_proc_delegate_manager()->RegisterTopLevelWindowProcDelegate(
898  [](HWND hwnd, UINT message, WPARAM wpar, LPARAM lpar, void* user_data,
899  LRESULT* result) {
900  switch (message) {
901  case WM_CLOSE: {
902  bool* called = reinterpret_cast<bool*>(user_data);
903  *called = true;
904  return true;
905  }
906  }
907  return false;
908  },
909  reinterpret_cast<void*>(&second_close));
910 
911  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
912  0);
913 
914  while (!second_close) {
915  engine->task_runner()->ProcessTasks();
916  }
917 }

References flutter::kResumed, message, and user_data.

◆ TEST_F() [55/155]

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

Definition at line 581 of file flutter_windows_engine_unittests.cc.

581  {
582  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
583  EXPECT_CALL(*windows_proc_table, GetHighContrastEnabled)
584  .WillOnce(Return(true))
585  .WillOnce(Return(false));
586 
587  FlutterWindowsEngineBuilder builder{GetContext()};
588  builder.SetWindowsProcTable(windows_proc_table);
589  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
590  EngineModifier modifier(engine.get());
591 
592  std::optional<FlutterAccessibilityFeature> engine_flags;
593  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
594  UpdateAccessibilityFeatures, ([&engine_flags](auto engine, auto flags) {
595  engine_flags = flags;
596  return kSuccess;
597  }));
598  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
599  SendPlatformMessage,
600  [](auto engine, const auto message) { return kSuccess; });
601 
602  // 1: High contrast is enabled.
603  engine->UpdateHighContrastMode();
604 
605  EXPECT_TRUE(engine->high_contrast_enabled());
606  EXPECT_TRUE(engine_flags.has_value());
607  EXPECT_TRUE(
608  engine_flags.value() &
609  FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
610 
611  // 2: High contrast is disabled.
612  engine_flags.reset();
613  engine->UpdateHighContrastMode();
614 
615  EXPECT_FALSE(engine->high_contrast_enabled());
616  EXPECT_TRUE(engine_flags.has_value());
617  EXPECT_FALSE(
618  engine_flags.value() &
619  FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
620 }

References message.

◆ TEST_F() [56/155]

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

Definition at line 310 of file flutter_window_unittests.cc.

310  {
311  MockFlutterWindow win32window;
312 
313  EXPECT_EQ(win32window.GetNativeViewAccessible(), nullptr);
314 }

◆ TEST_F() [57/155]

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

Definition at line 318 of file flutter_window_unittests.cc.

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

References message.

◆ TEST_F() [58/155]

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

Definition at line 382 of file flutter_window_unittests.cc.

382  {
383  MockFlutterWindow win32window;
384  EXPECT_CALL(win32window, GetWindowHandle)
385  .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
386  EXPECT_CALL(win32window, OnWindowStateEvent)
387  .WillRepeatedly([&](WindowStateEvent event) {
388  win32window.FlutterWindow::OnWindowStateEvent(event);
389  });
390  EXPECT_CALL(win32window, OnResize).Times(1);
391 
392  // Restore
393  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
394 
395  // Focus
396  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
397 
398  MockWindowBindingHandlerDelegate delegate;
399  bool focused = false;
400  bool restored = false;
401  EXPECT_CALL(delegate, OnWindowStateEvent)
402  .WillRepeatedly([&](HWND hwnd, WindowStateEvent event) {
403  if (event == WindowStateEvent::kFocus) {
404  focused = true;
405  } else if (event == WindowStateEvent::kShow) {
406  restored = true;
407  }
408  });
409 
410  win32window.SetView(&delegate);
411  EXPECT_TRUE(focused);
412  EXPECT_TRUE(restored);
413 }

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

◆ TEST_F() [59/155]

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

Definition at line 118 of file flutter_window_unittests.cc.

118  {
119  FlutterWindow window(800, 600);
120  ASSERT_TRUE(TRUE);
121 }

◆ TEST_F() [60/155]

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

Definition at line 350 of file flutter_window_unittests.cc.

350  {
351  MockFlutterWindow win32window;
352  EXPECT_CALL(win32window, GetWindowHandle)
353  .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
354  MockWindowBindingHandlerDelegate delegate;
355 
356  WindowStateEvent last_event;
357  EXPECT_CALL(delegate, OnWindowStateEvent)
358  .WillRepeatedly([&last_event](HWND hwnd, WindowStateEvent event) {
359  last_event = event;
360  });
361  EXPECT_CALL(win32window, OnWindowStateEvent)
362  .WillRepeatedly([&](WindowStateEvent event) {
363  win32window.FlutterWindow::OnWindowStateEvent(event);
364  });
365  EXPECT_CALL(win32window, OnResize).Times(AnyNumber());
366 
367  win32window.SetView(&delegate);
368 
369  win32window.InjectWindowMessage(WM_SIZE, 0, 0);
370  EXPECT_EQ(last_event, WindowStateEvent::kHide);
371 
372  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
373  EXPECT_EQ(last_event, WindowStateEvent::kShow);
374 
375  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
376  EXPECT_EQ(last_event, WindowStateEvent::kFocus);
377 
378  win32window.InjectWindowMessage(WM_KILLFOCUS, 0, 0);
379  EXPECT_EQ(last_event, WindowStateEvent::kUnfocus);
380 }

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

◆ TEST_F() [61/155]

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

Definition at line 123 of file flutter_window_unittests.cc.

123  {
124  FlutterWindow win32window(100, 100);
125  int old_handle_count = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
126 
127  constexpr size_t row_bytes = 100 * 4;
128  constexpr size_t height = 100;
129  std::array<char, row_bytes * height> allocation;
130  win32window.OnBitmapSurfaceUpdated(allocation.data(), row_bytes, height);
131 
132  int new_handle_count = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
133  // Check GDI resources leak
134  EXPECT_EQ(old_handle_count, new_handle_count);
135 }

References flutter::FlutterWindow::OnBitmapSurfaceUpdated().

◆ TEST_F() [62/155]

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

Definition at line 153 of file flutter_window_unittests.cc.

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

◆ TEST_F() [63/155]

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

Definition at line 140 of file flutter_window_unittests.cc.

140  {
141  MockFlutterWindow win32window;
142  EXPECT_CALL(win32window, GetDpiScale()).WillOnce(Return(1.0));
143 
144  Rect cursor_rect(Point(10, 20), Size(30, 40));
145  EXPECT_CALL(win32window, UpdateCursorRect(cursor_rect)).Times(1);
146 
147  win32window.OnCursorRectUpdated(cursor_rect);
148 }

◆ TEST_F() [64/155]

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

Definition at line 164 of file flutter_window_unittests.cc.

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

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

◆ TEST_F() [65/155]

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

Definition at line 265 of file flutter_window_unittests.cc.

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

◆ TEST_F() [66/155]

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

Definition at line 296 of file flutter_window_unittests.cc.

296  {
297  MockFlutterWindow win32window;
298  MockWindowBindingHandlerDelegate delegate;
299  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
300  win32window.SetView(&delegate);
301 
302  EXPECT_CALL(delegate, OnHighContrastChanged).Times(1);
303 
304  win32window.InjectWindowMessage(WM_THEMECHANGED, 0, 0);
305 }

◆ TEST_F() [67/155]

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

Definition at line 285 of file flutter_window_unittests.cc.

285  {
286  MockFlutterWindow win32window;
287  MockWindowBindingHandlerDelegate delegate;
288  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
289  win32window.SetView(&delegate);
290 
291  EXPECT_CALL(delegate, OnWindowRepaint()).Times(1);
292 
293  win32window.InjectWindowMessage(WM_PAINT, 0, 0);
294 }

◆ TEST_F() [68/155]

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

Definition at line 415 of file flutter_window_unittests.cc.

415  {
416  FlutterWindow win32window(100, 100);
417  win32window.UpdateFlutterCursor("text");
418  HCURSOR cursor = ::GetCursor();
419  EXPECT_EQ(cursor, ::LoadCursor(nullptr, IDC_IBEAM));
420 }

References flutter::FlutterWindow::UpdateFlutterCursor().

◆ TEST_F() [69/155]

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

Definition at line 1240 of file keyboard_unittests.cc.

1240  {
1241  KeyboardTester tester{GetContext()};
1242  tester.Responding(false);
1243 
1244  // German Keyboard layout
1245 
1246  // Press AltGr, which Win32 precedes with a ContrlLeft down.
1247  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1248  KeyStateChange{VK_LCONTROL, true, true},
1249  WmKeyDownInfo{VK_LCONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1250  kWmResultZero),
1251  KeyStateChange{VK_RMENU, true, true},
1252  WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1253  kWmResultZero)});
1254 
1255  EXPECT_EQ(tester.key_calls.size(), 2);
1256  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1257  kPhysicalControlLeft, kLogicalControlLeft, "",
1258  kNotSynthesized);
1259  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1260  kPhysicalAltRight, kLogicalAltRight, "",
1261  kNotSynthesized);
1262  tester.clear_key_calls();
1263  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1264 
1265  // Press Q
1266  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1267  WmKeyDownInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
1268  kWmResultZero),
1269  WmCharInfo{'@', kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
1270  kWmResultZero)});
1271 
1272  EXPECT_EQ(tester.key_calls.size(), 2);
1273  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1274  kPhysicalKeyQ, kLogicalKeyQ, "@", kNotSynthesized);
1275  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"@");
1276  tester.clear_key_calls();
1277  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1278 
1279  // Release Q
1280  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1281  WmKeyUpInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended}.Build(
1282  kWmResultZero)});
1283 
1284  EXPECT_EQ(tester.key_calls.size(), 1);
1285  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1286  kPhysicalKeyQ, kLogicalKeyQ, "", kNotSynthesized);
1287  tester.clear_key_calls();
1288  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1289 
1290  // Release AltGr. Win32 doesn't dispatch ControlLeft up. Instead Flutter will
1291  // forge one. The AltGr is a system key, therefore will be handled by Win32's
1292  // default WndProc.
1293  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1294  KeyStateChange{VK_LCONTROL, false, true},
1295  ExpectForgedMessage{
1296  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1297  kWmResultZero)},
1298  KeyStateChange{VK_RMENU, false, true},
1299  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1300  kWmResultDefault)});
1301 
1302  EXPECT_EQ(tester.key_calls.size(), 2);
1303  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1304  kPhysicalControlLeft, kLogicalControlLeft, "",
1305  kNotSynthesized);
1306  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1307  kPhysicalAltRight, kLogicalAltRight, "",
1308  kNotSynthesized);
1309  tester.clear_key_calls();
1310  // The sys key up must not be redispatched. The forged ControlLeft up will.
1311  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1312 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [70/155]

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

Definition at line 1327 of file keyboard_unittests.cc.

1327  {
1328  KeyboardTester tester{GetContext()};
1329  tester.Responding(false);
1330 
1331  // 1. AltGr down.
1332 
1333  // The key down event causes a ControlLeft down and a AltRight (extended
1334  // AltLeft) down.
1335  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1336  KeyStateChange{VK_LCONTROL, true, true},
1337  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1338  kWmResultZero),
1339  KeyStateChange{VK_RMENU, true, true},
1340  WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1341  kWmResultZero)});
1342 
1343  EXPECT_EQ(tester.key_calls.size(), 2);
1344  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1345  kPhysicalControlLeft, kLogicalControlLeft, "",
1346  kNotSynthesized);
1347  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1348  kPhysicalAltRight, kLogicalAltRight, "",
1349  kNotSynthesized);
1350  tester.clear_key_calls();
1351  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1352 
1353  // 2. AltGr up.
1354 
1355  // The key up event only causes a AltRight (extended AltLeft) up.
1356  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1357  KeyStateChange{VK_LCONTROL, false, true},
1358  ExpectForgedMessage{
1359  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1360  kWmResultZero)},
1361  KeyStateChange{VK_RMENU, false, true},
1362  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1363  kWmResultDefault)});
1364  EXPECT_EQ(tester.key_calls.size(), 2);
1365  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1366  kPhysicalControlLeft, kLogicalControlLeft, "",
1367  kNotSynthesized);
1368  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1369  kPhysicalAltRight, kLogicalAltRight, "",
1370  kNotSynthesized);
1371  tester.clear_key_calls();
1372  // The sys key up must not be redispatched. The forged ControlLeft up will.
1373  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1374 
1375  // 3. AltGr down (or: ControlLeft down then AltRight down.)
1376 
1377  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1378  KeyStateChange{VK_LCONTROL, true, false},
1379  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1380  kWmResultZero),
1381  KeyStateChange{VK_RMENU, true, true},
1382  WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1383  kWmResultZero)});
1384 
1385  EXPECT_EQ(tester.key_calls.size(), 2);
1386  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1387  kPhysicalControlLeft, kLogicalControlLeft, "",
1388  kNotSynthesized);
1389  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
1390  kPhysicalAltRight, kLogicalAltRight, "",
1391  kNotSynthesized);
1392  tester.clear_key_calls();
1393  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1394 
1395  // 4. AltGr up.
1396 
1397  // The key up event only causes a AltRight (extended AltLeft) up.
1398  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1399  KeyStateChange{VK_LCONTROL, false, false},
1400  ExpectForgedMessage{
1401  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1402  kWmResultZero)},
1403  KeyStateChange{VK_RMENU, false, false},
1404  WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1405  kWmResultDefault)});
1406  EXPECT_EQ(tester.key_calls.size(), 2);
1407  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1408  kPhysicalControlLeft, kLogicalControlLeft, "",
1409  kNotSynthesized);
1410  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
1411  kPhysicalAltRight, kLogicalAltRight, "",
1412  kNotSynthesized);
1413  tester.clear_key_calls();
1414  // The sys key up must not be redispatched. The forged ControlLeft up will.
1415  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1416 
1417  // 5. For key sequence 2: a real ControlLeft up.
1418  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1419  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1420  kWmResultZero)});
1421  EXPECT_EQ(tester.key_calls.size(), 1);
1422  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
1423  kNotSynthesized);
1424  tester.clear_key_calls();
1425  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
1426 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [71/155]

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

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

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

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

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

Definition at line 1150 of file keyboard_unittests.cc.

1150  {
1151  KeyboardTester tester{GetContext()};
1152  tester.Responding(false);
1153 
1154  // US Keyboard layout
1155 
1156  // Press ControlLeft
1157  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1158  KeyStateChange{VK_LCONTROL, true, true},
1159  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1160  kWmResultZero)});
1161 
1162  EXPECT_EQ(tester.key_calls.size(), 1);
1163  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1164  kPhysicalControlLeft, kLogicalControlLeft, "",
1165  kNotSynthesized);
1166  tester.clear_key_calls();
1167  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1168 
1169  // Press 1
1170  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1171  WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1172  .Build(kWmResultZero)});
1173 
1174  EXPECT_EQ(tester.key_calls.size(), 1);
1175  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1176  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1177  tester.clear_key_calls();
1178  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1179 
1180  // Release 1
1181  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1182  WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1183  kWmResultZero)});
1184 
1185  EXPECT_EQ(tester.key_calls.size(), 1);
1186  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1187  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1188  tester.clear_key_calls();
1189  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1190 
1191  // Release ControlLeft
1192  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1193  KeyStateChange{VK_LCONTROL, false, true},
1194  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1195  kWmResultZero)});
1196 
1197  EXPECT_EQ(tester.key_calls.size(), 1);
1198  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1199  kPhysicalControlLeft, kLogicalControlLeft, "",
1200  kNotSynthesized);
1201  tester.clear_key_calls();
1202  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1203 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [76/155]

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

Definition at line 1092 of file keyboard_unittests.cc.

1092  {
1093  KeyboardTester tester{GetContext()};
1094  tester.Responding(false);
1095 
1096  // US Keyboard layout
1097 
1098  // Press ControlLeft
1099  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1100  KeyStateChange{VK_LCONTROL, true, true},
1101  WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1102  kWmResultZero)});
1103 
1104  EXPECT_EQ(tester.key_calls.size(), 1);
1105  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1106  kPhysicalControlLeft, kLogicalControlLeft, "",
1107  kNotSynthesized);
1108  tester.clear_key_calls();
1109  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1110 
1111  // Press A
1112  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1113  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1114  kWmResultZero),
1115  WmCharInfo{0x01, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1116  kWmResultZero)});
1117 
1118  EXPECT_EQ(tester.key_calls.size(), 1);
1119  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1120  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1121  tester.clear_key_calls();
1122  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1123 
1124  // Release A
1125  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1126  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
1127  kWmResultZero)});
1128 
1129  EXPECT_EQ(tester.key_calls.size(), 1);
1130  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1131  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1132  tester.clear_key_calls();
1133  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1134 
1135  // Release ControlLeft
1136  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1137  KeyStateChange{VK_LCONTROL, false, true},
1138  WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1139  kWmResultZero)});
1140 
1141  EXPECT_EQ(tester.key_calls.size(), 1);
1142  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1143  kPhysicalControlLeft, kLogicalControlLeft, "",
1144  kNotSynthesized);
1145  tester.clear_key_calls();
1146  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1147 }

References EXPECT_CALL_IS_EVENT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [77/155]

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

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

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

Definition at line 1430 of file keyboard_unittests.cc.

1430  {
1431  KeyboardTester tester{GetContext()};
1432  tester.Responding(false);
1433 
1434  tester.SetLayout(LayoutFrench);
1435 
1436  // Press ^¨ (US: Left bracket)
1437  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1438  WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1439  kWmResultZero),
1440  WmDeadCharInfo{'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1441  kWmResultZero)});
1442 
1443  EXPECT_EQ(tester.key_calls.size(), 1);
1444  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1445  kPhysicalBracketLeft, kLogicalBracketRight, "^",
1446  kNotSynthesized);
1447  tester.clear_key_calls();
1448  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1449 
1450  // Release ^¨
1451  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1452  WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
1453  kWmResultZero)});
1454 
1455  EXPECT_EQ(tester.key_calls.size(), 1);
1456  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1457  kPhysicalBracketLeft, kLogicalBracketRight, "",
1458  kNotSynthesized);
1459  tester.clear_key_calls();
1460  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1461 
1462  // Press E
1463  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1464  WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1465  kWmResultZero),
1466  WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1467  kWmResultZero)});
1468 
1469  EXPECT_EQ(tester.key_calls.size(), 2);
1470  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1471  kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
1472  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"ê");
1473  tester.clear_key_calls();
1474  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1475 
1476  // Release E
1477  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1478  WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
1479  kWmResultZero)});
1480 
1481  EXPECT_EQ(tester.key_calls.size(), 1);
1482  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1483  kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
1484  tester.clear_key_calls();
1485  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1486 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [80/155]

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

Definition at line 1574 of file keyboard_unittests.cc.

1574  {
1575  KeyboardTester tester{GetContext()};
1576  tester.Responding(false);
1577 
1578  tester.SetLayout(LayoutFrench);
1579 
1580  // Press ^¨ (US: Left bracket)
1581  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1582  WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1583  kWmResultZero),
1584  WmDeadCharInfo{'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1585  kWmResultZero)});
1586 
1587  EXPECT_EQ(tester.key_calls.size(), 1);
1588  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1589  kPhysicalBracketLeft, kLogicalBracketRight, "^",
1590  kNotSynthesized);
1591  tester.clear_key_calls();
1592  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1593 
1594  // Release ^¨
1595  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1596  WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
1597  kWmResultZero)});
1598 
1599  EXPECT_EQ(tester.key_calls.size(), 1);
1600  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1601  kPhysicalBracketLeft, kLogicalBracketRight, "",
1602  kNotSynthesized);
1603  tester.clear_key_calls();
1604  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1605 
1606  // Press 1
1607  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1608  WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1609  .Build(kWmResultZero),
1610  WmCharInfo{'^', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1611  kWmResultZero),
1612  WmCharInfo{'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1613  kWmResultZero)});
1614 
1615  EXPECT_EQ(tester.key_calls.size(), 3);
1616  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1617  kPhysicalDigit1, kLogicalDigit1, "^", kNotSynthesized);
1618  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"^");
1619  EXPECT_CALL_IS_TEXT(tester.key_calls[2], u"&");
1620  tester.clear_key_calls();
1621  // TODO(dkwingsmt): This count should probably be 3. Currently the '^'
1622  // message is redispatched due to being part of the KeyDown session, which is
1623  // not handled by the framework, while the '&' message is not redispatched
1624  // for being a standalone message. We should resolve this inconsistency.
1625  // https://github.com/flutter/flutter/issues/98306
1626  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1627 
1628  // Release 1
1629  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1630  WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1631  kWmResultZero)});
1632 
1633  EXPECT_EQ(tester.key_calls.size(), 1);
1634  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1635  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1636  tester.clear_key_calls();
1637  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1638 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [81/155]

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

Definition at line 1643 of file keyboard_unittests.cc.

1643  {
1644  KeyboardTester tester{GetContext()};
1645  tester.Responding(false);
1646 
1647  // US INTL layout.
1648 
1649  // Press `
1650  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1651  WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1652  kWmResultZero),
1653  WmDeadCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1654  kWmResultZero)});
1655 
1656  EXPECT_EQ(tester.key_calls.size(), 1);
1657  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1658  kPhysicalBackquote, kLogicalBackquote, "`",
1659  kNotSynthesized);
1660  tester.clear_key_calls();
1661  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1662 
1663  // Release `
1664  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1665  WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
1666  kWmResultZero)});
1667 
1668  EXPECT_EQ(tester.key_calls.size(), 1);
1669  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1670  kPhysicalBackquote, kLogicalBackquote, "",
1671  kNotSynthesized);
1672  tester.clear_key_calls();
1673  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1674 
1675  // Press ` again.
1676  // The response should be slow.
1677  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
1678  tester.LateResponding(
1679  [&recorded_callbacks](
1680  const FlutterKeyEvent* event,
1681  MockKeyResponseController::ResponseCallback callback) {
1682  recorded_callbacks.push_back(callback);
1683  });
1684 
1685  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1686  WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1687  kWmResultZero),
1688  WmCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp, kBeingReleased,
1689  kNoContext, 1, /*bit25*/ true}
1690  .Build(kWmResultZero),
1691  WmCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1692  kWmResultZero)});
1693 
1694  EXPECT_EQ(recorded_callbacks.size(), 1);
1695  EXPECT_EQ(tester.key_calls.size(), 1);
1696  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1697  kPhysicalBackquote, kLogicalBackquote, "`",
1698  kNotSynthesized);
1699  tester.clear_key_calls();
1700  // Key down event responded with false.
1701  recorded_callbacks.front()(false);
1702  EXPECT_EQ(tester.key_calls.size(), 2);
1703  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"`");
1704  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"`");
1705  tester.clear_key_calls();
1706  // TODO(dkwingsmt): This count should probably be 3. See the comment above
1707  // that is marked with the same issue.
1708  // https://github.com/flutter/flutter/issues/98306
1709  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1710 
1711  tester.Responding(false);
1712 
1713  // Release `
1714  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1715  WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
1716  kWmResultZero)});
1717 
1718  EXPECT_EQ(tester.key_calls.size(), 1);
1719  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1720  kPhysicalBackquote, kLogicalBackquote, "",
1721  kNotSynthesized);
1722  tester.clear_key_calls();
1723  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1724 }

References callback, EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [82/155]

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

Definition at line 1493 of file keyboard_unittests.cc.

1493  {
1494  KeyboardTester tester{GetContext()};
1495  tester.Responding(false);
1496 
1497  // Press ShiftLeft
1498  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1499  KeyStateChange{VK_LSHIFT, true, true},
1500  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
1501  kWmResultZero)});
1502 
1503  EXPECT_EQ(tester.key_calls.size(), 1);
1504  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1505  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1506  kNotSynthesized);
1507  tester.clear_key_calls();
1508  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1509 
1510  // Press 6^
1511  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1512  WmKeyDownInfo{'6', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
1513  kWmResultZero),
1514  WmDeadCharInfo{'^', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
1515  kWmResultZero)});
1516 
1517  EXPECT_EQ(tester.key_calls.size(), 1);
1518  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1519  kPhysicalDigit6, kLogicalDigit6, "6", kNotSynthesized);
1520  tester.clear_key_calls();
1521  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1522 
1523  // Release 6^
1524  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1525  WmKeyUpInfo{'6', kScanCodeDigit6, kNotExtended}.Build(kWmResultZero)});
1526 
1527  EXPECT_EQ(tester.key_calls.size(), 1);
1528  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1529  kPhysicalDigit6, kLogicalDigit6, "", kNotSynthesized);
1530  tester.clear_key_calls();
1531  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1532 
1533  // Release ShiftLeft
1534  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1535  KeyStateChange{VK_LSHIFT, false, true},
1536  WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
1537  kWmResultZero)});
1538 
1539  EXPECT_EQ(tester.key_calls.size(), 1);
1540  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1541  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1542  kNotSynthesized);
1543  tester.clear_key_calls();
1544  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1545 
1546  // Press E
1547  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1548  WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1549  kWmResultZero),
1550  WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1551  kWmResultZero)});
1552 
1553  EXPECT_EQ(tester.key_calls.size(), 2);
1554  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1555  kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
1556  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"ê");
1557  tester.clear_key_calls();
1558  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1559 
1560  // Release E
1561  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1562  WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
1563  kWmResultZero)});
1564 
1565  EXPECT_EQ(tester.key_calls.size(), 1);
1566  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1567  kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
1568  tester.clear_key_calls();
1569  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1570 }

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [83/155]

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

Definition at line 1207 of file keyboard_unittests.cc.

1207  {
1208  KeyboardTester tester{GetContext()};
1209  tester.Responding(false);
1210 
1211  tester.SetLayout(LayoutFrench);
1212 
1213  // Press 1
1214  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1215  WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1216  .Build(kWmResultZero),
1217  WmCharInfo{'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1218  kWmResultZero)});
1219 
1220  EXPECT_EQ(tester.key_calls.size(), 2);
1221  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1222  kPhysicalDigit1, kLogicalDigit1, "&", kNotSynthesized);
1223  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"&");
1224  tester.clear_key_calls();
1225  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1226 
1227  // Release 1
1228  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1229  WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1230  kWmResultZero)});
1231 
1232  EXPECT_EQ(tester.key_calls.size(), 1);
1233  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1234  kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1235  tester.clear_key_calls();
1236  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1237 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [84/155]

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

Definition at line 2466 of file keyboard_unittests.cc.

2466  {
2467  KeyboardTester tester{GetContext()};
2468  tester.Responding(false);
2469 
2470  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2471  WmKeyDownInfo{VK_CAPITAL, 0, kNotExtended}.Build(),
2472  WmKeyUpInfo{VK_CAPITAL, 0, kNotExtended}.Build()});
2473 
2474  tester.clear_key_calls();
2475 }

◆ TEST_F() [85/155]

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

Definition at line 1992 of file keyboard_unittests.cc.

1992  {
1993  KeyboardTester tester{GetContext()};
1994  tester.Responding(false);
1995 
1996  // US Keyboard layout.
1997 
1998  // There should be preceding key events to make the keyboard into IME mode.
1999  // Omit them in this test since they are not relavent.
2000 
2001  // Press CtrlRight in IME mode.
2002  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2003  KeyStateChange{VK_RCONTROL, true, false},
2004  WmKeyDownInfo{VK_PROCESSKEY, kScanCodeControl, kExtended, kWasUp}.Build(
2005  kWmResultZero)});
2006 
2007  EXPECT_EQ(tester.key_calls.size(), 1);
2008  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2009  kNotSynthesized);
2010  tester.clear_key_calls();
2011  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2012 }

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [86/155]

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

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

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

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

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

Definition at line 1727 of file keyboard_unittests.cc.

1727  {
1728  KeyboardTester tester{GetContext()};
1729  tester.Responding(false);
1730 
1731  // Gothic Keyboard layout. (We need a layout that yields non-BMP characters
1732  // without IME, which is actually very rare.)
1733 
1734  // Press key W of a US keyboard, which should yield character '𐍅'.
1735  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1736  WmKeyDownInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1737  kWmResultZero),
1738  WmCharInfo{0xd800, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1739  kWmResultZero),
1740  WmCharInfo{0xdf45, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1741  kWmResultZero)});
1742 
1743  const char* st = tester.key_calls[0].key_event.character;
1744 
1745  EXPECT_EQ(tester.key_calls.size(), 2);
1746  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1747  kPhysicalKeyW, kLogicalKeyW, "𐍅", kNotSynthesized);
1748  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"𐍅");
1749  tester.clear_key_calls();
1750  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
1751 
1752  // Release W
1753  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1754  WmKeyUpInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended}.Build(
1755  kWmResultZero)});
1756 
1757  EXPECT_EQ(tester.key_calls.size(), 1);
1758  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1759  kPhysicalKeyW, kLogicalKeyW, "", kNotSynthesized);
1760  tester.clear_key_calls();
1761  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1762 }

References EXPECT_CALL_IS_EVENT, and EXPECT_CALL_IS_TEXT.

◆ TEST_F() [91/155]

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

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

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

Definition at line 1032 of file keyboard_unittests.cc.

1032  {
1033  KeyboardTester tester{GetContext()};
1034  tester.Responding(false);
1035 
1036  // US Keyboard layout
1037 
1038  // Press ShiftLeft
1039  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1040  KeyStateChange{VK_LSHIFT, true, true},
1041  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
1042  kWmResultZero)});
1043 
1044  EXPECT_EQ(tester.key_calls.size(), 1);
1045  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1046  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1047  kNotSynthesized);
1048  tester.clear_key_calls();
1049  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1050 
1051  // Press A
1052  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1053  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1054  kWmResultZero),
1055  WmCharInfo{'A', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1056  kWmResultZero)});
1057 
1058  EXPECT_EQ(tester.key_calls.size(), 2);
1059  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
1060  kPhysicalKeyA, kLogicalKeyA, "A", kNotSynthesized);
1061  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"A");
1062  tester.clear_key_calls();
1063  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1064 
1065  // Release ShiftLeft
1066  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1067  KeyStateChange{VK_LSHIFT, false, true},
1068  WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
1069  kWmResultZero)});
1070 
1071  EXPECT_EQ(tester.key_calls.size(), 1);
1072  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1073  kPhysicalShiftLeft, kLogicalShiftLeft, "",
1074  kNotSynthesized);
1075  tester.clear_key_calls();
1076  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1077 
1078  // Release A
1079  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1080  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
1081  kWmResultZero)});
1082 
1083  EXPECT_EQ(tester.key_calls.size(), 1);
1084  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
1085  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1086  tester.clear_key_calls();
1087  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1088 }

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

◆ TEST_F() [94/155]

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

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

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

Definition at line 2059 of file keyboard_unittests.cc.

2059  {
2060  KeyboardTester tester{GetContext()};
2061 
2062  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2063 
2064  // Store callbacks to manually call them.
2065  tester.LateResponding(
2066  [&recorded_callbacks](
2067  const FlutterKeyEvent* event,
2068  MockKeyResponseController::ResponseCallback callback) {
2069  recorded_callbacks.push_back(callback);
2070  });
2071 
2072  // Press A
2073  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2074  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2075  kWmResultZero),
2076  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2077  kWmResultZero)});
2078 
2079  // Hold A
2080  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2081  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
2082  kWmResultZero),
2083  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
2084  kWmResultZero)});
2085 
2086  EXPECT_EQ(tester.key_calls.size(), 1);
2087  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2088  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2089  EXPECT_EQ(recorded_callbacks.size(), 1);
2090  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2091 
2092  // The first response.
2093  recorded_callbacks.front()(false);
2094 
2095  EXPECT_EQ(tester.key_calls.size(), 3);
2096  EXPECT_EQ(recorded_callbacks.size(), 2);
2097  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2098  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeRepeat,
2099  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2100  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2101 
2102  // The second response.
2103  recorded_callbacks.back()(false);
2104 
2105  EXPECT_EQ(tester.key_calls.size(), 4);
2106  EXPECT_CALL_IS_TEXT(tester.key_calls[3], u"a");
2107  tester.clear_key_calls();
2108  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2109 }

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

◆ TEST_F() [97/155]

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

Definition at line 2122 of file keyboard_unittests.cc.

2122  {
2123  KeyboardTester tester{GetContext()};
2124  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2125 
2126  // Store callbacks to manually call them.
2127  tester.LateResponding(
2128  [&recorded_callbacks](
2129  const FlutterKeyEvent* event,
2130  MockKeyResponseController::ResponseCallback callback) {
2131  recorded_callbacks.push_back(callback);
2132  });
2133 
2134  // Press A
2135  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2136  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2137  kWmResultZero),
2138  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2139  kWmResultZero)});
2140 
2141  EXPECT_EQ(tester.key_calls.size(), 1);
2142  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2143  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2144  tester.clear_key_calls();
2145  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2146 
2147  // Release A
2148  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2149  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2150  kWmResultZero)});
2151 
2152  EXPECT_EQ(tester.key_calls.size(), 0);
2153  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2154 
2155  // The first down event responded with false.
2156  EXPECT_EQ(recorded_callbacks.size(), 1);
2157  recorded_callbacks.front()(false);
2158 
2159  EXPECT_EQ(tester.key_calls.size(), 2);
2160  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"a");
2161  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
2162  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2163  tester.clear_key_calls();
2164  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2165 
2166  // Press A again
2167  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2168  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2169  kWmResultZero),
2170  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2171  kWmResultZero)});
2172 
2173  // Nothing more was dispatched because the first up event hasn't been
2174  // responded yet.
2175  EXPECT_EQ(recorded_callbacks.size(), 2);
2176  EXPECT_EQ(tester.key_calls.size(), 0);
2177  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2178 
2179  // The first up event responded with false, which was redispatched, and caused
2180  // the down event to be dispatched.
2181  recorded_callbacks.back()(false);
2182  EXPECT_EQ(tester.key_calls.size(), 1);
2183  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2184  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2185  tester.clear_key_calls();
2186  EXPECT_EQ(recorded_callbacks.size(), 3);
2187  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2188 
2189  // Release A again
2190  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2191  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2192  kWmResultZero)});
2193 
2194  EXPECT_EQ(tester.key_calls.size(), 0);
2195  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2196 }

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

◆ TEST_F() [98/155]

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

Definition at line 1764 of file keyboard_unittests.cc.

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

References EXPECT_CALL_IS_EVENT.

◆ TEST_F() [99/155]

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

Definition at line 2198 of file keyboard_unittests.cc.

2198  {
2199  KeyboardTester tester{GetContext()};
2200  tester.Responding(false);
2201 
2202  // US Keyboard layout
2203 
2204  tester.InjectPlatformMessage(
2205  "flutter/textinput", "TextInput.setClient",
2206  R"|([108, {"inputAction": "TextInputAction.none"}])|");
2207 
2208  // Press Enter
2209  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2210  WmKeyDownInfo{VK_RETURN, kScanCodeEnter, kNotExtended, kWasUp}.Build(
2211  kWmResultZero),
2212  WmCharInfo{'\n', kScanCodeEnter, kNotExtended, kWasUp}.Build(
2213  kWmResultZero)});
2214 
2215  EXPECT_EQ(tester.key_calls.size(), 2);
2216  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2217  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
2218  EXPECT_CALL_IS_TEXT_METHOD_CALL(
2219  tester.key_calls[1],
2220  "{"
2221  R"|("method":"TextInputClient.performAction",)|"
2222  R"|("args":[108,"TextInputAction.none"])|"
2223  "}");
2224  tester.clear_key_calls();
2225  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2226 
2227  // Release Enter
2228  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2229  WmKeyUpInfo{VK_RETURN, kScanCodeEnter, kNotExtended}.Build(
2230  kWmResultZero)});
2231 
2232  EXPECT_EQ(tester.key_calls.size(), 1);
2233  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2234  kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
2235  tester.clear_key_calls();
2236  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2237 
2238  // Make sure OnText is not obstructed after pressing Enter.
2239  //
2240  // Regression test for https://github.com/flutter/flutter/issues/97706.
2241 
2242  // Press A
2243  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2244  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2245  kWmResultZero),
2246  WmCharInfo{'a', kScanCodeKeyA, 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  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2252  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2253  tester.clear_key_calls();
2254 
2255  // Release A
2256  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2257  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2258  kWmResultZero)});
2259 
2260  EXPECT_EQ(tester.key_calls.size(), 1);
2261  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2262  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2263  tester.clear_key_calls();
2264 }

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

◆ TEST_F() [100/155]

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

Definition at line 2020 of file keyboard_unittests.cc.

2020  {
2021  KeyboardTester tester{GetContext()};
2022  tester.Responding(true);
2023 
2024  // US Keyboard layout.
2025 
2026  // Press CtrlRight in IME mode.
2027  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2028  KeyStateChange{VK_LSHIFT, true, false},
2029  WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
2030  kWmResultZero),
2031  WmKeyDownInfo{VK_PROCESSKEY, kScanCodeDigit2, kNotExtended, kWasUp}.Build(
2032  kWmResultZero),
2033  KeyStateChange{VK_LSHIFT, false, true},
2034  WmKeyUpInfo{VK_PROCESSKEY, kScanCodeShiftLeft, kNotExtended}.Build(
2035  kWmResultZero),
2036  WmKeyUpInfo{'2', kScanCodeDigit2, kNotExtended, kWasUp}.Build(
2037  kWmResultZero)});
2038 
2039  EXPECT_EQ(tester.key_calls.size(), 4);
2040  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2041  kPhysicalShiftLeft, kLogicalShiftLeft, "",
2042  kNotSynthesized);
2043  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown, 0, 0, "",
2044  kNotSynthesized);
2045  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeUp,
2046  kPhysicalShiftLeft, kLogicalShiftLeft, "",
2047  kNotSynthesized);
2048  EXPECT_CALL_IS_EVENT(tester.key_calls[3], kFlutterKeyEventTypeDown, 0, 0, "",
2049  kNotSynthesized);
2050  tester.clear_key_calls();
2051 }

References EXPECT_CALL_IS_EVENT, and flutter::kScanCodeShiftLeft.

◆ TEST_F() [101/155]

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

Definition at line 2266 of file keyboard_unittests.cc.

2266  {
2267  // In this test, the user presses the folloing keys:
2268  //
2269  // Key Current text
2270  // ===========================
2271  // A a
2272  // F à
2273  //
2274  // And the Backspace event is responded immediately.
2275 
2276  KeyboardTester tester{GetContext()};
2277  tester.Responding(false);
2278 
2279  // US Keyboard layout
2280 
2281  // Press A
2282  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2283  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2284  kWmResultZero),
2285  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2286  kWmResultZero)});
2287 
2288  EXPECT_EQ(tester.key_calls.size(), 2);
2289  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2290  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2291  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2292  tester.clear_key_calls();
2293  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2294 
2295  // Release A
2296  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2297  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2298  kWmResultZero)});
2299 
2300  EXPECT_EQ(tester.key_calls.size(), 1);
2301  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2302  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2303  tester.clear_key_calls();
2304  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2305 
2306  // Press F, which is translated to:
2307  //
2308  // Backspace down, char & up, then VK_PACKET('à').
2309  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2310  WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2311  kWmResultZero),
2312  WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2313  kWmResultZero),
2314  WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2315  kWmResultZero),
2316  WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2317  WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2318  WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2319 
2320  EXPECT_EQ(tester.key_calls.size(), 3);
2321  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2322  kPhysicalBackspace, kLogicalBackspace, "",
2323  kNotSynthesized);
2324  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
2325  kPhysicalBackspace, kLogicalBackspace, "",
2326  kNotSynthesized);
2327  EXPECT_CALL_IS_TEXT(tester.key_calls[2], u"à");
2328  tester.clear_key_calls();
2329  // TODO(dkwingsmt): This count should probably be 4. Currently the CHAR 0x8
2330  // message is redispatched due to being part of the KeyDown session, which is
2331  // not handled by the framework, while the 'à' message is not redispatched
2332  // for being a standalone message. We should resolve this inconsistency.
2333  // https://github.com/flutter/flutter/issues/98306
2334  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
2335 
2336  // Release F
2337  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2338  WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2339  /* overwrite_prev_state_0 */ true}
2340  .Build(kWmResultZero)});
2341 
2342  EXPECT_EQ(tester.key_calls.size(), 1);
2343  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2344  kNotSynthesized);
2345  tester.clear_key_calls();
2346  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2347 }

References EXPECT_CALL_IS_EVENT, EXPECT_CALL_IS_TEXT, kScanCodeKeyA, and kVirtualKeyA.

◆ TEST_F() [102/155]

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

Definition at line 2456 of file keyboard_unittests.cc.

2456  {
2457  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), false);
2458 }

References VietnameseTelexAddDiacriticWithSlowResponse().

◆ TEST_F() [103/155]

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

Definition at line 2460 of file keyboard_unittests.cc.

2460  {
2461  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), true);
2462 }

References VietnameseTelexAddDiacriticWithSlowResponse().

◆ TEST_F() [104/155]

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

Definition at line 267 of file platform_handler_unittests.cc.

267  {
268  UseEngineWithView();
269 
270  TestBinaryMessenger messenger;
271  PlatformHandler platform_handler(&messenger, engine(), []() {
272  auto clipboard = std::make_unique<MockScopedClipboard>();
273 
274  EXPECT_CALL(*clipboard.get(), Open)
275  .Times(1)
276  .WillOnce(Return(kErrorSuccess));
277  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
278 
279  return clipboard;
280  });
281 
282  std::string result =
283  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
284 
285  EXPECT_EQ(result, "[{\"value\":true}]");
286 }

References kErrorSuccess.

◆ TEST_F() [105/155]

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

Definition at line 336 of file platform_handler_unittests.cc.

336  {
337  UseEngineWithView();
338 
339  TestBinaryMessenger messenger;
340  PlatformHandler platform_handler(&messenger, engine(), []() {
341  auto clipboard = std::make_unique<MockScopedClipboard>();
342 
343  EXPECT_CALL(*clipboard.get(), Open)
344  .Times(1)
345  .WillOnce(Return(kAccessDeniedErrorCode));
346 
347  return clipboard;
348  });
349 
350  std::string result =
351  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
352 
353  EXPECT_EQ(result, "[{\"value\":false}]");
354 }

References kAccessDeniedErrorCode.

◆ TEST_F() [106/155]

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

Definition at line 309 of file platform_handler_unittests.cc.

309  {
310  UseEngineWithView();
311 
312  TestBinaryMessenger messenger;
313  PlatformHandler platform_handler(&messenger, engine());
314 
315  std::string result = SimulatePlatformMessage(
316  &messenger, kClipboardHasStringsFakeContentTypeMessage);
317 
318  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
319 }

◆ TEST_F() [107/155]

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

Definition at line 356 of file platform_handler_unittests.cc.

356  {
357  UseEngineWithView();
358 
359  TestBinaryMessenger messenger;
360  PlatformHandler platform_handler(&messenger, engine(), []() {
361  auto clipboard = std::make_unique<MockScopedClipboard>();
362 
363  EXPECT_CALL(*clipboard.get(), Open)
364  .Times(1)
365  .WillOnce(Return(kArbitraryErrorCode));
366 
367  return clipboard;
368  });
369 
370  std::string result =
371  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
372 
373  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
374 }

◆ TEST_F() [108/155]

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

Definition at line 321 of file platform_handler_unittests.cc.

321  {
322  UseHeadlessEngine();
323 
324  TestBinaryMessenger messenger;
325  PlatformHandler platform_handler(&messenger, engine());
326 
327  std::string result =
328  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
329 
330  EXPECT_EQ(result,
331  "[\"Clipboard error\",\"Clipboard is not available in Windows "
332  "headless mode\",null]");
333 }

◆ TEST_F() [109/155]

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

Definition at line 288 of file platform_handler_unittests.cc.

288  {
289  UseEngineWithView();
290 
291  TestBinaryMessenger messenger;
292  PlatformHandler platform_handler(&messenger, engine(), []() {
293  auto clipboard = std::make_unique<MockScopedClipboard>();
294 
295  EXPECT_CALL(*clipboard.get(), Open)
296  .Times(1)
297  .WillOnce(Return(kErrorSuccess));
298  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(false));
299 
300  return clipboard;
301  });
302 
303  std::string result =
304  SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
305 
306  EXPECT_EQ(result, "[{\"value\":false}]");
307 }

References kErrorSuccess.

◆ TEST_F() [110/155]

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

Definition at line 376 of file platform_handler_unittests.cc.

376  {
377  UseEngineWithView();
378 
379  TestBinaryMessenger messenger;
380  PlatformHandler platform_handler(&messenger, engine(), []() {
381  auto clipboard = std::make_unique<MockScopedClipboard>();
382 
383  EXPECT_CALL(*clipboard.get(), Open)
384  .Times(1)
385  .WillOnce(Return(kErrorSuccess));
386  EXPECT_CALL(*clipboard.get(), SetString)
387  .Times(1)
388  .WillOnce([](std::wstring string) {
389  EXPECT_EQ(string, L"hello");
390  return kErrorSuccess;
391  });
392 
393  return clipboard;
394  });
395 
396  std::string result =
397  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
398 
399  EXPECT_EQ(result, "[null]");
400 }

References kErrorSuccess.

◆ TEST_F() [111/155]

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

Definition at line 441 of file platform_handler_unittests.cc.

441  {
442  UseEngineWithView();
443 
444  TestBinaryMessenger messenger;
445  PlatformHandler platform_handler(&messenger, engine(), []() {
446  auto clipboard = std::make_unique<MockScopedClipboard>();
447 
448  EXPECT_CALL(*clipboard.get(), Open)
449  .Times(1)
450  .WillOnce(Return(kArbitraryErrorCode));
451 
452  return clipboard;
453  });
454 
455  std::string result =
456  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
457 
458  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
459 }

◆ TEST_F() [112/155]

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

Definition at line 461 of file platform_handler_unittests.cc.

461  {
462  UseEngineWithView();
463 
464  TestBinaryMessenger messenger;
465  PlatformHandler platform_handler(&messenger, engine(), []() {
466  auto clipboard = std::make_unique<MockScopedClipboard>();
467 
468  EXPECT_CALL(*clipboard.get(), Open)
469  .Times(1)
470  .WillOnce(Return(kErrorSuccess));
471  EXPECT_CALL(*clipboard.get(), SetString)
472  .Times(1)
473  .WillOnce(Return(kArbitraryErrorCode));
474 
475  return clipboard;
476  });
477 
478  std::string result =
479  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
480 
481  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to set clipboard data\",1]");
482 }

References kErrorSuccess.

◆ TEST_F() [113/155]

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

Definition at line 427 of file platform_handler_unittests.cc.

427  {
428  UseHeadlessEngine();
429 
430  TestBinaryMessenger messenger;
431  PlatformHandler platform_handler(&messenger, engine());
432 
433  std::string result =
434  SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
435 
436  EXPECT_EQ(result,
437  "[\"Clipboard error\",\"Clipboard is not available in Windows "
438  "headless mode\",null]");
439 }

◆ TEST_F() [114/155]

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

Definition at line 403 of file platform_handler_unittests.cc.

403  {
404  UseEngineWithView();
405 
406  TestBinaryMessenger messenger;
407  PlatformHandler platform_handler(&messenger, engine());
408 
409  std::string result =
410  SimulatePlatformMessage(&messenger, kClipboardSetDataNullTextMessage);
411 
412  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
413 }

◆ TEST_F() [115/155]

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

Definition at line 415 of file platform_handler_unittests.cc.

415  {
416  UseEngineWithView();
417 
418  TestBinaryMessenger messenger;
419  PlatformHandler platform_handler(&messenger, engine());
420 
421  std::string result =
422  SimulatePlatformMessage(&messenger, kClipboardSetDataUnknownTypeMessage);
423 
424  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
425 }

◆ TEST_F() [116/155]

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

Definition at line 172 of file platform_handler_unittests.cc.

172  {
173  UseEngineWithView();
174 
175  TestBinaryMessenger messenger;
176  PlatformHandler platform_handler(&messenger, engine(), []() {
177  auto clipboard = std::make_unique<MockScopedClipboard>();
178 
179  EXPECT_CALL(*clipboard.get(), Open)
180  .Times(1)
181  .WillOnce(Return(kErrorSuccess));
182  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
183  EXPECT_CALL(*clipboard.get(), GetString)
184  .Times(1)
185  .WillOnce(Return(std::wstring(L"Hello world")));
186 
187  return clipboard;
188  });
189 
190  std::string result =
191  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
192 
193  EXPECT_EQ(result, "[{\"text\":\"Hello world\"}]");
194 }

References kErrorSuccess.

◆ TEST_F() [117/155]

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

Definition at line 196 of file platform_handler_unittests.cc.

196  {
197  UseEngineWithView();
198 
199  TestBinaryMessenger messenger;
200  PlatformHandler platform_handler(&messenger, engine());
201 
202  // Requesting an unknown content type is an error.
203  std::string result = SimulatePlatformMessage(
204  &messenger, kClipboardGetDataFakeContentTypeMessage);
205 
206  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
207 }

◆ TEST_F() [118/155]

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

Definition at line 243 of file platform_handler_unittests.cc.

243  {
244  UseEngineWithView();
245 
246  TestBinaryMessenger messenger;
247  PlatformHandler platform_handler(&messenger, engine(), []() {
248  auto clipboard = std::make_unique<MockScopedClipboard>();
249 
250  EXPECT_CALL(*clipboard.get(), Open)
251  .Times(1)
252  .WillOnce(Return(kErrorSuccess));
253  EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
254  EXPECT_CALL(*clipboard.get(), GetString)
255  .Times(1)
256  .WillOnce(Return(kArbitraryErrorCode));
257 
258  return clipboard;
259  });
260 
261  std::string result =
262  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
263 
264  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to get clipboard data\",1]");
265 }

References kErrorSuccess.

◆ TEST_F() [119/155]

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

Definition at line 223 of file platform_handler_unittests.cc.

223  {
224  UseEngineWithView();
225 
226  TestBinaryMessenger messenger;
227  PlatformHandler platform_handler(&messenger, engine(), []() {
228  auto clipboard = std::make_unique<MockScopedClipboard>();
229 
230  EXPECT_CALL(*clipboard.get(), Open)
231  .Times(1)
232  .WillOnce(Return(kArbitraryErrorCode));
233 
234  return clipboard;
235  });
236 
237  std::string result =
238  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
239 
240  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
241 }

◆ TEST_F() [120/155]

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

Definition at line 209 of file platform_handler_unittests.cc.

209  {
210  UseHeadlessEngine();
211 
212  TestBinaryMessenger messenger;
213  PlatformHandler platform_handler(&messenger, engine());
214 
215  std::string result =
216  SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
217 
218  EXPECT_EQ(result,
219  "[\"Clipboard error\",\"Clipboard is not available in "
220  "Windows headless mode\",null]");
221 }

◆ TEST_F() [121/155]

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

Definition at line 484 of file platform_handler_unittests.cc.

484  {
485  UseHeadlessEngine();
486 
487  TestBinaryMessenger messenger;
488  MockPlatformHandler platform_handler(&messenger, engine());
489 
490  EXPECT_CALL(platform_handler, SystemSoundPlay("SystemSoundType.alert", _))
491  .WillOnce([](const std::string& sound,
492  std::unique_ptr<MethodResult<rapidjson::Document>> result) {
493  result->Success();
494  });
495 
496  std::string result =
497  SimulatePlatformMessage(&messenger, kSystemSoundTypeAlertMessage);
498 
499  EXPECT_EQ(result, "[null]");
500 }

◆ TEST_F() [122/155]

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

Definition at line 524 of file platform_handler_unittests.cc.

524  {
525  UseHeadlessEngine();
526  bool called_cancel = false;
527 
528  TestBinaryMessenger messenger(
529  [&called_cancel](const std::string& channel, const uint8_t* message,
530  size_t size, BinaryReply reply) {
531  reply(reinterpret_cast<const uint8_t*>(kExitResponseCancelMessage),
532  sizeof(kExitResponseCancelMessage));
533  called_cancel = true;
534  });
535  MockPlatformHandler platform_handler(&messenger, engine());
536 
537  EXPECT_CALL(platform_handler, QuitApplication).Times(0);
538 
539  std::string result = SimulatePlatformMessage(
540  &messenger, kSystemExitApplicationCancelableMessage);
541  EXPECT_EQ(result, "[{\"response\":\"cancel\"}]");
542  EXPECT_TRUE(called_cancel);
543 }

References message.

◆ TEST_F() [123/155]

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

Definition at line 545 of file platform_handler_unittests.cc.

545  {
546  UseHeadlessEngine();
547  bool called_cancel = false;
548  UINT exit_code = 0;
549 
550  TestBinaryMessenger messenger(
551  [&called_cancel](const std::string& channel, const uint8_t* message,
552  size_t size, BinaryReply reply) {
553  reply(reinterpret_cast<const uint8_t*>(kExitResponseExitMessage),
554  sizeof(kExitResponseExitMessage));
555  called_cancel = true;
556  });
557  MockPlatformHandler platform_handler(&messenger, engine());
558 
559  ON_CALL(platform_handler, QuitApplication)
560  .WillByDefault([&exit_code](std::optional<HWND> hwnd,
561  std::optional<WPARAM> wparam,
562  std::optional<LPARAM> lparam,
563  UINT ec) { exit_code = ec; });
564  EXPECT_CALL(platform_handler, QuitApplication).Times(1);
565 
566  std::string result = SimulatePlatformMessage(
567  &messenger, kSystemExitApplicationCancelableMessage);
568  EXPECT_EQ(result, "[{\"response\":\"cancel\"}]");
569  EXPECT_TRUE(called_cancel);
570  EXPECT_EQ(exit_code, 2);
571 }

References message.

◆ TEST_F() [124/155]

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

Definition at line 502 of file platform_handler_unittests.cc.

502  {
503  UseHeadlessEngine();
504  UINT exit_code = 0;
505 
506  TestBinaryMessenger messenger([](const std::string& channel,
507  const uint8_t* message, size_t size,
508  BinaryReply reply) {});
509  MockPlatformHandler platform_handler(&messenger, engine());
510 
511  ON_CALL(platform_handler, QuitApplication)
512  .WillByDefault([&exit_code](std::optional<HWND> hwnd,
513  std::optional<WPARAM> wparam,
514  std::optional<LPARAM> lparam,
515  UINT ec) { exit_code = ec; });
516  EXPECT_CALL(platform_handler, QuitApplication).Times(1);
517 
518  std::string result = SimulatePlatformMessage(
519  &messenger, kSystemExitApplicationRequiredMessage);
520  EXPECT_EQ(result, "[{\"response\":\"exit\"}]");
521  EXPECT_EQ(exit_code, 1);
522 }

References message.

◆ TEST_F() [125/155]

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

Definition at line 207 of file text_input_plugin_unittest.cc.

207  {
208  UseHeadlessEngine();
209 
210  TestBinaryMessenger messenger([](const std::string& channel,
211  const uint8_t* message, size_t message_size,
212  BinaryReply reply) {});
213 
214  std::string reply;
215  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
216  size_t reply_size) {
217  reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
218  };
219 
220  TextInputPlugin handler(&messenger, engine());
221 
222  auto& codec = JsonMethodCodec::GetInstance();
223  auto message = codec.EncodeMethodCall({"TextInput.clearClient", nullptr});
224  messenger.SimulateEngineMessage(kChannelName, message->data(),
225  message->size(), reply_handler);
226 
227  EXPECT_EQ(reply,
228  "[\"Internal Consistency Error\",\"Text input is not available in "
229  "Windows headless mode\",null]");
230 }

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

◆ TEST_F() [126/155]

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

Definition at line 188 of file text_input_plugin_unittest.cc.

188  {
189  UseEngineWithView();
190 
191  TestBinaryMessenger messenger([](const std::string& channel,
192  const uint8_t* message, size_t message_size,
193  BinaryReply reply) {});
194  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
195 
196  TextInputPlugin handler(&messenger, engine());
197 
198  EXPECT_CALL(*view(), OnResetImeComposing());
199 
200  auto& codec = JsonMethodCodec::GetInstance();
201  auto message = codec.EncodeMethodCall({"TextInput.clearClient", nullptr});
202  messenger.SimulateEngineMessage(kChannelName, message->data(),
203  message->size(), reply_handler);
204 }

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

◆ TEST_F() [127/155]

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

Definition at line 453 of file text_input_plugin_unittest.cc.

453  {
454  UseEngineWithView();
455 
456  int selection_base = -1;
457  TestBinaryMessenger messenger([&](const std::string& channel,
458  const uint8_t* message, size_t size,
459  BinaryReply reply) {
460  auto method = JsonMethodCodec::GetInstance().DecodeMethodCall(
461  std::vector<uint8_t>(message, message + size));
462  if (method->method_name() == kUpdateEditingStateMethod) {
463  const auto& args = *method->arguments();
464  const auto& editing_state = args[1];
465  auto base = editing_state.FindMember(kSelectionBaseKey);
466  auto extent = editing_state.FindMember(kSelectionExtentKey);
467  ASSERT_NE(base, editing_state.MemberEnd());
468  ASSERT_TRUE(base->value.IsInt());
469  ASSERT_NE(extent, editing_state.MemberEnd());
470  ASSERT_TRUE(extent->value.IsInt());
471  selection_base = base->value.GetInt();
472  EXPECT_EQ(extent->value.GetInt(), selection_base);
473  }
474  });
475 
476  TextInputPlugin plugin(&messenger, engine());
477 
478  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
479  auto& allocator = args->GetAllocator();
480  args->PushBack(123, allocator); // client_id
481  rapidjson::Value client_config(rapidjson::kObjectType);
482  args->PushBack(client_config, allocator);
483  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
484  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
485  EXPECT_TRUE(messenger.SimulateEngineMessage(
486  kChannelName, encoded->data(), encoded->size(),
487  [](const uint8_t* reply, size_t reply_size) {}));
488 
489  plugin.ComposeBeginHook();
490  EXPECT_EQ(selection_base, 0);
491  plugin.ComposeChangeHook(u"abc", 3);
492  EXPECT_EQ(selection_base, 3);
493 
494  plugin.ComposeCommitHook();
495  plugin.ComposeEndHook();
496  EXPECT_EQ(selection_base, 3);
497 
498  plugin.ComposeBeginHook();
499  plugin.ComposeChangeHook(u"1", 1);
500  EXPECT_EQ(selection_base, 4);
501 
502  plugin.ComposeChangeHook(u"12", 2);
503  EXPECT_EQ(selection_base, 5);
504 
505  plugin.ComposeChangeHook(u"12", 1);
506  EXPECT_EQ(selection_base, 4);
507 
508  plugin.ComposeChangeHook(u"12", 2);
509  EXPECT_EQ(selection_base, 5);
510 }

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

◆ TEST_F() [128/155]

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

Definition at line 583 of file text_input_plugin_unittest.cc.

583  {
584  UseHeadlessEngine();
585 
586  TestBinaryMessenger messenger([](const std::string& channel,
587  const uint8_t* message, size_t message_size,
588  BinaryReply reply) {});
589 
590  std::string reply;
591  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
592  size_t reply_size) {
593  reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
594  };
595 
596  TextInputPlugin handler(&messenger, engine());
597 
598  auto& codec = JsonMethodCodec::GetInstance();
599 
600  auto arguments =
601  std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
602  auto& allocator = arguments->GetAllocator();
603 
604  arguments->AddMember("x", 0, allocator);
605  arguments->AddMember("y", 0, allocator);
606  arguments->AddMember("width", 0, allocator);
607  arguments->AddMember("height", 0, allocator);
608 
609  auto message = codec.EncodeMethodCall(
610  {"TextInput.setMarkedTextRect", std::move(arguments)});
611  messenger.SimulateEngineMessage(kChannelName, message->data(),
612  message->size(), reply_handler);
613 
614  EXPECT_EQ(reply,
615  "[\"Internal Consistency Error\",\"Text input is not available in "
616  "Windows headless mode\",null]");
617 }

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

◆ TEST_F() [129/155]

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

Definition at line 395 of file text_input_plugin_unittest.cc.

395  {
396  UseEngineWithView();
397 
398  auto handled_message = CreateResponse(true);
399  auto unhandled_message = CreateResponse(false);
400  int received_scancode = 0;
401 
402  TestBinaryMessenger messenger(
403  [&received_scancode, &handled_message, &unhandled_message](
404  const std::string& channel, const uint8_t* message,
405  size_t message_size, BinaryReply reply) {});
406 
407  int redispatch_scancode = 0;
408  TextInputPlugin handler(&messenger, engine());
409 
410  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
411  auto& allocator = args->GetAllocator();
412  args->PushBack(123, allocator); // client_id
413 
414  rapidjson::Value client_config(rapidjson::kObjectType);
415  client_config.AddMember(kEnableDeltaModel, true, allocator);
416 
417  args->PushBack(client_config, allocator);
418  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
419  MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
420 
421  EXPECT_TRUE(messenger.SimulateEngineMessage(
422  kChannelName, encoded->data(), encoded->size(),
423  [](const uint8_t* reply, size_t reply_size) {}));
424 
425  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
426  handler.ComposeBeginHook();
427  std::u16string text;
428  text.push_back('\n');
429  handler.ComposeChangeHook(text, 1);
430  handler.ComposeEndHook();
431 
432  handler.KeyboardHook(0x4E, 100, WM_KEYDOWN, 'n', false, false);
433  handler.ComposeBeginHook();
434  std::u16string textN;
435  text.push_back('n');
436  handler.ComposeChangeHook(textN, 1);
437  handler.KeyboardHook(0x49, 100, WM_KEYDOWN, 'i', false, false);
438  std::u16string textNi;
439  text.push_back('n');
440  text.push_back('i');
441  handler.ComposeChangeHook(textNi, 2);
442  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
443  std::u16string textChineseCharacter;
444  text.push_back(u'\u4F60');
445  handler.ComposeChangeHook(textChineseCharacter, 1);
446  handler.ComposeCommitHook();
447  handler.ComposeEndHook();
448 
449  // Passes if it did not crash
450 }

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, message, and text.

◆ TEST_F() [130/155]

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

Definition at line 163 of file text_input_plugin_unittest.cc.

163  {
164  UseEngineWithView();
165 
166  auto handled_message = CreateResponse(true);
167  auto unhandled_message = CreateResponse(false);
168  int received_scancode = 0;
169 
170  TestBinaryMessenger messenger(
171  [&received_scancode, &handled_message, &unhandled_message](
172  const std::string& channel, const uint8_t* message,
173  size_t message_size, BinaryReply reply) {});
174 
175  int redispatch_scancode = 0;
176  TextInputPlugin handler(&messenger, engine());
177 
178  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
179  handler.ComposeBeginHook();
180  std::u16string text;
181  text.push_back('\n');
182  handler.ComposeChangeHook(text, 1);
183  handler.ComposeEndHook();
184 
185  // Passes if it did not crash
186 }

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

◆ TEST_F() [131/155]

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

Definition at line 512 of file text_input_plugin_unittest.cc.

512  {
513  UseEngineWithView();
514 
515  // A position of `EditableText`.
516  double view_x = 100;
517  double view_y = 200;
518 
519  // A position and size of marked text, in `EditableText` local coordinates.
520  double ime_x = 3;
521  double ime_y = 4;
522  double ime_width = 50;
523  double ime_height = 60;
524 
525  // Transformation matrix.
526  std::array<std::array<double, 4>, 4> editabletext_transform = {
527  1.0, 0.0, 0.0, view_x, //
528  0.0, 1.0, 0.0, view_y, //
529  0.0, 0.0, 0.0, 0.0, //
530  0.0, 0.0, 0.0, 1.0};
531 
532  TestBinaryMessenger messenger([](const std::string& channel,
533  const uint8_t* message, size_t message_size,
534  BinaryReply reply) {});
535  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
536 
537  TextInputPlugin handler(&messenger, engine());
538 
539  auto& codec = JsonMethodCodec::GetInstance();
540 
541  EXPECT_CALL(*view(), OnCursorRectUpdated(Rect{{view_x, view_y}, {0, 0}}));
542 
543  {
544  auto arguments =
545  std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
546  auto& allocator = arguments->GetAllocator();
547 
548  rapidjson::Value transoform(rapidjson::kArrayType);
549  for (int i = 0; i < 4 * 4; i++) {
550  // Pack 2-dimensional array by column-major order.
551  transoform.PushBack(editabletext_transform[i % 4][i / 4], allocator);
552  }
553 
554  arguments->AddMember("transform", transoform, allocator);
555 
556  auto message = codec.EncodeMethodCall(
557  {"TextInput.setEditableSizeAndTransform", std::move(arguments)});
558  messenger.SimulateEngineMessage(kChannelName, message->data(),
559  message->size(), reply_handler);
560  }
561 
562  EXPECT_CALL(*view(),
563  OnCursorRectUpdated(Rect{{view_x + ime_x, view_y + ime_y},
564  {ime_width, ime_height}}));
565 
566  {
567  auto arguments =
568  std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
569  auto& allocator = arguments->GetAllocator();
570 
571  arguments->AddMember("x", ime_x, allocator);
572  arguments->AddMember("y", ime_y, allocator);
573  arguments->AddMember("width", ime_width, allocator);
574  arguments->AddMember("height", ime_height, allocator);
575 
576  auto message = codec.EncodeMethodCall(
577  {"TextInput.setMarkedTextRect", std::move(arguments)});
578  messenger.SimulateEngineMessage(kChannelName, message->data(),
579  message->size(), reply_handler);
580  }
581 }

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

◆ TEST_F() [132/155]

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

Definition at line 234 of file text_input_plugin_unittest.cc.

234  {
235  UseEngineWithView();
236 
237  bool sent_message = false;
238  TestBinaryMessenger messenger(
239  [&sent_message](const std::string& channel, const uint8_t* message,
240  size_t message_size,
241  BinaryReply reply) { sent_message = true; });
242  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
243 
244  TextInputPlugin handler(&messenger, engine());
245 
246  auto& codec = JsonMethodCodec::GetInstance();
247 
248  // Call TextInput.setClient to initialize the TextInputModel.
249  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
250  auto& allocator = arguments->GetAllocator();
251  arguments->PushBack(kDefaultClientId, allocator);
252  rapidjson::Value config(rapidjson::kObjectType);
253  config.AddMember("inputAction", "done", allocator);
254  config.AddMember("inputType", "text", allocator);
255  config.AddMember(kEnableDeltaModel, false, allocator);
256  arguments->PushBack(config, allocator);
257  auto message =
258  codec.EncodeMethodCall({"TextInput.setClient", std::move(arguments)});
259  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
260  message->size(), reply_handler);
261 
262  // ComposeBeginHook should send state update.
263  sent_message = false;
264  handler.ComposeBeginHook();
265  EXPECT_TRUE(sent_message);
266 
267  // ComposeChangeHook should send state update.
268  sent_message = false;
269  handler.ComposeChangeHook(u"4", 1);
270  EXPECT_TRUE(sent_message);
271 
272  // ComposeCommitHook should NOT send state update.
273  //
274  // Commit messages are always immediately followed by a change message or an
275  // end message, both of which will send an update. Sending intermediate state
276  // with a collapsed composing region will trigger the framework to assume
277  // composing has ended, which is not the case until a WM_IME_ENDCOMPOSING
278  // event is received in the main event loop, which will trigger a call to
279  // ComposeEndHook.
280  sent_message = false;
281  handler.ComposeCommitHook();
282  EXPECT_FALSE(sent_message);
283 
284  // ComposeEndHook should send state update.
285  sent_message = false;
286  handler.ComposeEndHook();
287  EXPECT_TRUE(sent_message);
288 }

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

◆ TEST_F() [133/155]

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

Definition at line 290 of file text_input_plugin_unittest.cc.

290  {
291  UseEngineWithView();
292 
293  // Store messages as std::string for convenience.
294  std::vector<std::string> messages;
295 
296  TestBinaryMessenger messenger(
297  [&messages](const std::string& channel, const uint8_t* message,
298  size_t message_size, BinaryReply reply) {
299  std::string last_message(reinterpret_cast<const char*>(message),
300  message_size);
301  messages.push_back(last_message);
302  });
303  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
304 
305  TextInputPlugin handler(&messenger, engine());
306 
307  auto& codec = JsonMethodCodec::GetInstance();
308 
309  // Call TextInput.setClient to initialize the TextInputModel.
310  auto set_client_arguments =
311  EncodedClientConfig("TextInputType.multiline", "TextInputAction.newline");
312  auto message = codec.EncodeMethodCall(
313  {"TextInput.setClient", std::move(set_client_arguments)});
314  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
315  message->size(), reply_handler);
316 
317  // Simulate a key down event for '\n'.
318  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
319 
320  // Two messages are expected, the first is TextInput.updateEditingState and
321  // the second is TextInputClient.performAction.
322  EXPECT_EQ(messages.size(), 2);
323 
324  // Editing state should have been updated.
325  auto encoded_arguments = EncodedEditingState("\n", TextRange(1));
326  auto update_state_message = codec.EncodeMethodCall(
327  {kUpdateEditingStateMethod, std::move(encoded_arguments)});
328 
329  EXPECT_TRUE(std::equal(update_state_message->begin(),
330  update_state_message->end(),
331  messages.front().begin()));
332 
333  // TextInputClient.performAction should have been called.
334  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
335  auto& allocator = arguments->GetAllocator();
336  arguments->PushBack(kDefaultClientId, allocator);
337  arguments->PushBack(
338  rapidjson::Value("TextInputAction.newline", allocator).Move(), allocator);
339  auto invoke_action_message = codec.EncodeMethodCall(
340  {"TextInputClient.performAction", std::move(arguments)});
341 
342  EXPECT_TRUE(std::equal(invoke_action_message->begin(),
343  invoke_action_message->end(),
344  messages.back().begin()));
345 }

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

◆ TEST_F() [134/155]

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

Definition at line 348 of file text_input_plugin_unittest.cc.

348  {
349  UseEngineWithView();
350 
351  std::vector<std::vector<uint8_t>> messages;
352 
353  TestBinaryMessenger messenger(
354  [&messages](const std::string& channel, const uint8_t* message,
355  size_t message_size, BinaryReply reply) {
356  int length = static_cast<int>(message_size);
357  std::vector<uint8_t> last_message(length);
358  memcpy(&last_message[0], &message[0], length * sizeof(uint8_t));
359  messages.push_back(last_message);
360  });
361  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
362 
363  TextInputPlugin handler(&messenger, engine());
364 
365  auto& codec = JsonMethodCodec::GetInstance();
366 
367  // Call TextInput.setClient to initialize the TextInputModel.
368  auto set_client_arguments =
369  EncodedClientConfig("TextInputType.multiline", "TextInputAction.send");
370  auto message = codec.EncodeMethodCall(
371  {"TextInput.setClient", std::move(set_client_arguments)});
372  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
373  message->size(), reply_handler);
374 
375  // Simulate a key down event for '\n'.
376  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
377 
378  // Only a call to TextInputClient.performAction is expected.
379  EXPECT_EQ(messages.size(), 1);
380 
381  // TextInputClient.performAction should have been called.
382  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
383  auto& allocator = arguments->GetAllocator();
384  arguments->PushBack(kDefaultClientId, allocator);
385  arguments->PushBack(
386  rapidjson::Value("TextInputAction.send", allocator).Move(), allocator);
387  auto invoke_action_message = codec.EncodeMethodCall(
388  {"TextInputClient.performAction", std::move(arguments)});
389 
390  EXPECT_TRUE(std::equal(invoke_action_message->begin(),
391  invoke_action_message->end(),
392  messages.front().begin()));
393 }

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

◆ TEST_F() [135/155]

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

Definition at line 15 of file windows_lifecycle_manager_unittests.cc.

15  {
16  WindowsLifecycleManager manager(nullptr);
17  HWND win1 = reinterpret_cast<HWND>(1);
18  HWND win2 = reinterpret_cast<HWND>(2);
19 
20  // Hidden to inactive upon window shown.
21  manager.SetLifecycleState(AppLifecycleState::kHidden);
22  manager.OnWindowStateEvent(win1, WindowStateEvent::kShow);
23  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
24 
25  // Showing a second window does not change state.
26  manager.OnWindowStateEvent(win2, WindowStateEvent::kShow);
27  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
28 
29  // Inactive to resumed upon window focus.
30  manager.OnWindowStateEvent(win2, WindowStateEvent::kFocus);
31  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
32 
33  // Showing a second window does not change state.
34  manager.OnWindowStateEvent(win1, WindowStateEvent::kFocus);
35  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
36 
37  // Unfocusing one window does not change state while another is focused.
38  manager.OnWindowStateEvent(win1, WindowStateEvent::kUnfocus);
39  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
40 
41  // Unfocusing final remaining focused window transitions to inactive.
42  manager.OnWindowStateEvent(win2, WindowStateEvent::kUnfocus);
43  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
44 
45  // Hiding one of two visible windows does not change state.
46  manager.OnWindowStateEvent(win2, WindowStateEvent::kHide);
47  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
48 
49  // Hiding only visible window transitions to hidden.
50  manager.OnWindowStateEvent(win1, WindowStateEvent::kHide);
51  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kHidden);
52 
53  // Transition directly from resumed to hidden when the window is hidden.
54  manager.OnWindowStateEvent(win1, WindowStateEvent::kShow);
55  manager.OnWindowStateEvent(win1, WindowStateEvent::kFocus);
56  manager.OnWindowStateEvent(win1, WindowStateEvent::kHide);
57  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kHidden);
58 }

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

◆ TEST_F() [136/155]

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

Definition at line 124 of file flutter_windows_unittests.cc.

124  {
125  auto& context = GetContext();
126  WindowsConfigBuilder builder(context);
127  EnginePtr engine{builder.RunHeadless()};
128  ASSERT_NE(engine, nullptr);
129 
130  // Create and then destroy a view controller that does not own its engine.
131  // This causes the engine to transition back to headless mode.
132  {
133  FlutterDesktopViewControllerProperties properties = {};
134  ViewControllerPtr controller{
135  FlutterDesktopEngineCreateViewController(engine.get(), &properties)};
136 
137  ASSERT_NE(controller, nullptr);
138  }
139 
140  // The engine is back in headless mode now.
141  ASSERT_NE(engine, nullptr);
142 }

References FlutterDesktopEngineCreateViewController().

◆ TEST_F() [137/155]

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

Definition at line 343 of file flutter_windows_unittests.cc.

343  {
344  auto& context = GetContext();
345  WindowsConfigBuilder builder(context);
346  ViewControllerPtr controller{builder.Run()};
347  ASSERT_NE(controller, nullptr);
348  auto view = FlutterDesktopViewControllerGetView(controller.get());
349 
350  Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
351  dxgi_adapter = FlutterDesktopViewGetGraphicsAdapter(view);
352  ASSERT_NE(dxgi_adapter, nullptr);
353  DXGI_ADAPTER_DESC desc{};
354  ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
355 }

References FlutterDesktopViewControllerGetView(), and FlutterDesktopViewGetGraphicsAdapter().

◆ TEST_F() [138/155]

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

Definition at line 332 of file flutter_windows_unittests.cc.

332  {
333  auto& context = GetContext();
334  WindowsConfigBuilder builder(context);
335  ViewControllerPtr controller{builder.Run()};
336  ASSERT_NE(controller, nullptr);
337  FlutterDesktopViewId view_id =
338  FlutterDesktopViewControllerGetViewId(controller.get());
339 
340  ASSERT_EQ(view_id, static_cast<FlutterDesktopViewId>(kImplicitViewId));
341 }

References FlutterDesktopViewControllerGetViewId(), and flutter::kImplicitViewId.

◆ TEST_F() [139/155]

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

Definition at line 170 of file flutter_windows_unittests.cc.

170  {
171  auto& context = GetContext();
172  WindowsConfigBuilder builder(context);
173  builder.SetDartEntrypoint("customEntrypoint");
174  EnginePtr engine{builder.InitializeEngine()};
175  ASSERT_NE(engine, nullptr);
176 
177  ASSERT_FALSE(FlutterDesktopEngineRun(engine.get(), "conflictingEntrypoint"));
178 }

References FlutterDesktopEngineRun().

◆ TEST_F() [140/155]

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

Definition at line 93 of file flutter_windows_unittests.cc.

93  {
94  auto& context = GetContext();
95  WindowsConfigBuilder builder(context);
96  builder.SetDartEntrypoint("customEntrypoint");
97  ViewControllerPtr controller{builder.Run()};
98  ASSERT_NE(controller, nullptr);
99 }

◆ TEST_F() [141/155]

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

Definition at line 106 of file flutter_windows_unittests.cc.

106  {
107  auto& context = GetContext();
108  WindowsConfigBuilder builder(context);
109  EnginePtr engine{builder.InitializeEngine()};
110  ASSERT_NE(engine, nullptr);
111 
112  ASSERT_TRUE(FlutterDesktopEngineRun(engine.get(), "customEntrypoint"));
113 }

References FlutterDesktopEngineRun().

◆ TEST_F() [142/155]

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

Definition at line 116 of file flutter_windows_unittests.cc.

116  {
117  auto& context = GetContext();
118  WindowsConfigBuilder builder(context);
119  EnginePtr engine{builder.RunHeadless()};
120  ASSERT_NE(engine, nullptr);
121 }

◆ TEST_F() [143/155]

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

Definition at line 66 of file flutter_windows_unittests.cc.

66  {
67  auto& context = GetContext();
68  WindowsConfigBuilder builder(context);
69  ViewControllerPtr controller{builder.Run()};
70  ASSERT_NE(controller, nullptr);
71 }

◆ TEST_F() [144/155]

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

Definition at line 74 of file flutter_windows_unittests.cc.

74  {
75  // Replace stdout & stderr stream buffers with our own.
76  StreamCapture stdout_capture(&std::cout);
77  StreamCapture stderr_capture(&std::cerr);
78 
79  auto& context = GetContext();
80  WindowsConfigBuilder builder(context);
81  ViewControllerPtr controller{builder.Run()};
82  ASSERT_NE(controller, nullptr);
83 
84  stdout_capture.Stop();
85  stderr_capture.Stop();
86 
87  // Verify stdout & stderr have no output.
88  EXPECT_TRUE(stdout_capture.GetOutput().empty());
89  EXPECT_TRUE(stderr_capture.GetOutput().empty());
90 }

◆ TEST_F() [145/155]

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

Definition at line 145 of file flutter_windows_unittests.cc.

145  {
146  auto& context = GetContext();
147  WindowsConfigBuilder builder(context);
148  EnginePtr engine{builder.InitializeEngine()};
149  EngineModifier modifier{
150  reinterpret_cast<FlutterWindowsEngine*>(engine.get())};
151 
152  auto called = false;
153  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
154  UpdateAccessibilityFeatures, ([&called](auto engine, auto flags) {
155  called = true;
156  return kSuccess;
157  }));
158 
159  ViewControllerPtr controller{
160  FlutterDesktopViewControllerCreate(0, 0, engine.release())};
161 
162  ASSERT_TRUE(called);
163 }

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

◆ TEST_F() [146/155]

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

Definition at line 435 of file flutter_windows_unittests.cc.

435  {
436  auto& context = GetContext();
437  WindowsConfigBuilder builder(context);
438  EnginePtr engine{builder.InitializeEngine()};
439  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
440  EngineModifier modifier{windows_engine};
441 
442  auto lifecycle_manager =
443  std::make_unique<MockWindowsLifecycleManager>(windows_engine);
444  auto lifecycle_manager_ptr = lifecycle_manager.get();
445  modifier.SetLifecycleManager(std::move(lifecycle_manager));
446 
447  EXPECT_CALL(*lifecycle_manager_ptr,
448  SetLifecycleState(AppLifecycleState::kResumed))
449  .WillOnce([lifecycle_manager_ptr](AppLifecycleState state) {
450  lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
451  state);
452  });
453 
454  EXPECT_CALL(*lifecycle_manager_ptr,
455  SetLifecycleState(AppLifecycleState::kHidden))
456  .WillOnce([lifecycle_manager_ptr](AppLifecycleState state) {
457  lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
458  state);
459  });
460 
461  // Create a controller. This launches the engine and sets the app lifecycle
462  // to the "resumed" state.
463  ViewControllerPtr controller{
464  FlutterDesktopViewControllerCreate(0, 0, engine.release())};
465 
466  FlutterDesktopViewRef view =
467  FlutterDesktopViewControllerGetView(controller.get());
468  ASSERT_NE(view, nullptr);
469 
470  HWND hwnd = FlutterDesktopViewGetHWND(view);
471  ASSERT_NE(hwnd, nullptr);
472 
473  // Give the window a non-zero size to show it. This does not change the app
474  // lifecycle directly. However, destroying the view will now result in a
475  // "hidden" app lifecycle event.
476  ::MoveWindow(hwnd, /* X */ 0, /* Y */ 0, /* nWidth*/ 100, /* nHeight*/ 100,
477  /* bRepaint*/ false);
478 }

References FlutterDesktopViewControllerCreate(), FlutterDesktopViewControllerGetView(), FlutterDesktopViewGetHWND(), flutter::kHidden, and flutter::kResumed.

◆ TEST_F() [147/155]

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

Definition at line 278 of file flutter_windows_unittests.cc.

278  {
279  struct Captures {
280  fml::AutoResetWaitableEvent frame_scheduled_latch;
281  fml::AutoResetWaitableEvent frame_drawn_latch;
282  std::thread::id thread_id;
283  };
284  Captures captures;
285 
286  CreateNewThread("test_platform_thread")->PostTask([&]() {
287  captures.thread_id = std::this_thread::get_id();
288 
289  auto& context = GetContext();
290  WindowsConfigBuilder builder(context);
291  builder.SetDartEntrypoint("drawHelloWorld");
292 
293  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
294  ASSERT_FALSE(captures.frame_drawn_latch.IsSignaledForTest());
295  captures.frame_scheduled_latch.Signal();
296  });
297  context.AddNativeFunction("NotifyFirstFrameScheduled", native_entry);
298 
299  ViewControllerPtr controller{builder.Run()};
300  ASSERT_NE(controller, nullptr);
301 
302  auto engine = FlutterDesktopViewControllerGetEngine(controller.get());
303 
304  FlutterDesktopEngineSetNextFrameCallback(
305  engine,
306  [](void* user_data) {
307  auto captures = static_cast<Captures*>(user_data);
308 
309  ASSERT_TRUE(captures->frame_scheduled_latch.IsSignaledForTest());
310 
311  // Callback should execute on platform thread.
312  ASSERT_EQ(std::this_thread::get_id(), captures->thread_id);
313 
314  // Signal the test passed and end the Windows message loop.
315  captures->frame_drawn_latch.Signal();
316  ::PostQuitMessage(0);
317  },
318  &captures);
319 
320  // Pump messages for the Windows platform task runner.
321  ::MSG msg;
322  while (::GetMessage(&msg, nullptr, 0, 0)) {
323  ::TranslateMessage(&msg);
324  ::DispatchMessage(&msg);
325  }
326  });
327 
328  captures.frame_drawn_latch.Wait();
329 }

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

◆ TEST_F() [148/155]

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

Definition at line 223 of file flutter_windows_unittests.cc.

223  {
224  auto& context = GetContext();
225  WindowsConfigBuilder builder(context);
226  builder.SetDartEntrypoint("readPlatformExecutable");
227 
228  std::string executable_name;
229  fml::AutoResetWaitableEvent latch;
230  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
231  auto handle = Dart_GetNativeArgument(args, 0);
232  ASSERT_FALSE(Dart_IsError(handle));
233  executable_name = tonic::DartConverter<std::string>::FromDart(handle);
234  latch.Signal();
235  });
236  context.AddNativeFunction("SignalStringValue", native_entry);
237 
238  ViewControllerPtr controller{builder.Run()};
239  ASSERT_NE(controller, nullptr);
240 
241  // Wait until signalStringValue has been called.
242  latch.Wait();
243  EXPECT_EQ(executable_name, "flutter_windows_unittests.exe");
244 }

◆ TEST_F() [149/155]

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

Definition at line 358 of file flutter_windows_unittests.cc.

358  {
359  auto& context = GetContext();
360  WindowsConfigBuilder builder(context);
361  ViewControllerPtr controller{builder.Run()};
362  ASSERT_NE(controller, nullptr);
363 
364  FlutterDesktopEngineRef engine =
365  FlutterDesktopViewControllerGetEngine(controller.get());
366  FlutterDesktopPluginRegistrarRef registrar =
367  FlutterDesktopEngineGetPluginRegistrar(engine, "foo_bar");
368  FlutterDesktopViewRef implicit_view =
369  FlutterDesktopPluginRegistrarGetView(registrar);
370 
371  ASSERT_NE(implicit_view, nullptr);
372 }

References FlutterDesktopEngineGetPluginRegistrar(), FlutterDesktopPluginRegistrarGetView(), and FlutterDesktopViewControllerGetEngine().

◆ TEST_F() [150/155]

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

Definition at line 374 of file flutter_windows_unittests.cc.

374  {
375  auto& context = GetContext();
376  WindowsConfigBuilder builder(context);
377  ViewControllerPtr controller{builder.Run()};
378  ASSERT_NE(controller, nullptr);
379 
380  FlutterDesktopEngineRef engine =
381  FlutterDesktopViewControllerGetEngine(controller.get());
382  FlutterDesktopPluginRegistrarRef registrar =
383  FlutterDesktopEngineGetPluginRegistrar(engine, "foo_bar");
384 
385  FlutterDesktopViewId view_id =
386  FlutterDesktopViewControllerGetViewId(controller.get());
387  FlutterDesktopViewRef view =
388  FlutterDesktopPluginRegistrarGetViewById(registrar, view_id);
389 
390  FlutterDesktopViewRef view_123 = FlutterDesktopPluginRegistrarGetViewById(
391  registrar, static_cast<FlutterDesktopViewId>(123));
392 
393  ASSERT_NE(view, nullptr);
394  ASSERT_EQ(view_123, nullptr);
395 }

References FlutterDesktopEngineGetPluginRegistrar(), FlutterDesktopPluginRegistrarGetViewById(), FlutterDesktopViewControllerGetEngine(), and FlutterDesktopViewControllerGetViewId().

◆ TEST_F() [151/155]

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

Definition at line 397 of file flutter_windows_unittests.cc.

397  {
398  auto& context = GetContext();
399  WindowsConfigBuilder builder(context);
400  EnginePtr engine{builder.RunHeadless()};
401  ASSERT_NE(engine, nullptr);
402 
403  FlutterDesktopPluginRegistrarRef registrar =
404  FlutterDesktopEngineGetPluginRegistrar(engine.get(), "foo_bar");
405 
406  FlutterDesktopViewRef implicit_view =
407  FlutterDesktopPluginRegistrarGetView(registrar);
408  FlutterDesktopViewRef view_123 = FlutterDesktopPluginRegistrarGetViewById(
409  registrar, static_cast<FlutterDesktopViewId>(123));
410 
411  ASSERT_EQ(implicit_view, nullptr);
412  ASSERT_EQ(view_123, nullptr);
413 }

References FlutterDesktopEngineGetPluginRegistrar(), FlutterDesktopPluginRegistrarGetView(), and FlutterDesktopPluginRegistrarGetViewById().

◆ TEST_F() [152/155]

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

Definition at line 417 of file flutter_windows_unittests.cc.

417  {
418  auto& context = GetContext();
419  WindowsConfigBuilder builder(context);
420  EnginePtr engine{builder.InitializeEngine()};
421  EngineModifier modifier{
422  reinterpret_cast<FlutterWindowsEngine*>(engine.get())};
423 
424  auto egl_manager = std::make_unique<HalfBrokenEGLManager>();
425  ASSERT_TRUE(egl_manager->IsValid());
426  modifier.SetEGLManager(std::move(egl_manager));
427 
428  ViewControllerPtr controller{
429  FlutterDesktopViewControllerCreate(0, 0, engine.release())};
430 
431  ASSERT_NE(controller, nullptr);
432 }

References FlutterDesktopViewControllerCreate().

◆ TEST_F() [153/155]

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

Definition at line 181 of file flutter_windows_unittests.cc.

181  {
182  auto& context = GetContext();
183  WindowsConfigBuilder builder(context);
184  builder.SetDartEntrypoint("verifyNativeFunction");
185 
186  fml::AutoResetWaitableEvent latch;
187  auto native_entry =
188  CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); });
189  context.AddNativeFunction("Signal", native_entry);
190 
191  ViewControllerPtr controller{builder.Run()};
192  ASSERT_NE(controller, nullptr);
193 
194  // Wait until signal has been called.
195  latch.Wait();
196 }

◆ TEST_F() [154/155]

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

Definition at line 200 of file flutter_windows_unittests.cc.

200  {
201  auto& context = GetContext();
202  WindowsConfigBuilder builder(context);
203  builder.SetDartEntrypoint("verifyNativeFunctionWithParameters");
204 
205  bool bool_value = false;
206  fml::AutoResetWaitableEvent latch;
207  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
208  auto handle = Dart_GetNativeBooleanArgument(args, 0, &bool_value);
209  ASSERT_FALSE(Dart_IsError(handle));
210  latch.Signal();
211  });
212  context.AddNativeFunction("SignalBoolValue", native_entry);
213 
214  ViewControllerPtr controller{builder.Run()};
215  ASSERT_NE(controller, nullptr);
216 
217  // Wait until signalBoolValue has been called.
218  latch.Wait();
219  EXPECT_TRUE(bool_value);
220 }

◆ TEST_F() [155/155]

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

Definition at line 248 of file flutter_windows_unittests.cc.

248  {
249  auto& context = GetContext();
250  WindowsConfigBuilder builder(context);
251  builder.SetDartEntrypoint("verifyNativeFunctionWithReturn");
252 
253  bool bool_value_to_return = true;
254  fml::CountDownLatch latch(2);
255  auto bool_return_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
256  Dart_SetBooleanReturnValue(args, bool_value_to_return);
257  latch.CountDown();
258  });
259  context.AddNativeFunction("SignalBoolReturn", bool_return_entry);
260 
261  bool bool_value_passed = false;
262  auto bool_pass_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
263  auto handle = Dart_GetNativeBooleanArgument(args, 0, &bool_value_passed);
264  ASSERT_FALSE(Dart_IsError(handle));
265  latch.CountDown();
266  });
267  context.AddNativeFunction("SignalBoolValue", bool_pass_entry);
268 
269  ViewControllerPtr controller{builder.Run()};
270  ASSERT_NE(controller, nullptr);
271 
272  // Wait until signalBoolReturn and signalBoolValue have been called.
273  latch.Wait();
274  EXPECT_TRUE(bool_value_passed);
275 }

◆ VietnameseTelexAddDiacriticWithSlowResponse()

void flutter::testing::VietnameseTelexAddDiacriticWithSlowResponse ( WindowsTestContext &  context,
bool  backspace_response 
)

Definition at line 2349 of file keyboard_unittests.cc.

2350  {
2351  // In this test, the user presses the following keys:
2352  //
2353  // Key Current text
2354  // ===========================
2355  // A a
2356  // F à
2357  //
2358  // And the Backspace down event is responded slowly with `backspace_response`.
2359 
2360  KeyboardTester tester{context};
2361  tester.Responding(false);
2362 
2363  // US Keyboard layout
2364 
2365  // Press A
2366  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2367  WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2368  kWmResultZero),
2369  WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
2370  kWmResultZero)});
2371 
2372  EXPECT_EQ(tester.key_calls.size(), 2);
2373  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2374  kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2375  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
2376  tester.clear_key_calls();
2377  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2378 
2379  // Release A
2380  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2381  WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
2382  kWmResultZero)});
2383 
2384  EXPECT_EQ(tester.key_calls.size(), 1);
2385  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2386  kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2387  tester.clear_key_calls();
2388  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2389 
2390  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2391  tester.LateResponding(
2392  [&recorded_callbacks](
2393  const FlutterKeyEvent* event,
2394  MockKeyResponseController::ResponseCallback callback) {
2395  recorded_callbacks.push_back(callback);
2396  });
2397 
2398  // Press F, which is translated to:
2399  //
2400  // Backspace down, char & up, VK_PACKET('à').
2401  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2402  WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2403  kWmResultZero),
2404  WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2405  kWmResultZero),
2406  WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2407  kWmResultZero),
2408  WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2409  WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2410  WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2411 
2412  // The Backspace event has not responded yet, therefore the char message must
2413  // hold. This is because when the framework is handling the Backspace event,
2414  // it will send a setEditingState message that updates the text state that has
2415  // the last character deleted (denoted by `string1`). Processing the char
2416  // message before then will cause the final text to set to `string1`.
2417  EXPECT_EQ(tester.key_calls.size(), 1);
2418  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
2419  kPhysicalBackspace, kLogicalBackspace, "",
2420  kNotSynthesized);
2421  tester.clear_key_calls();
2422  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2423 
2424  EXPECT_EQ(recorded_callbacks.size(), 1);
2425  recorded_callbacks[0](backspace_response);
2426 
2427  EXPECT_EQ(tester.key_calls.size(), 1);
2428  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
2429  kPhysicalBackspace, kLogicalBackspace, "",
2430  kNotSynthesized);
2431  tester.clear_key_calls();
2432  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(),
2433  backspace_response ? 0 : 2);
2434 
2435  recorded_callbacks[1](false);
2436  EXPECT_EQ(tester.key_calls.size(), 1);
2437  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"à");
2438  tester.clear_key_calls();
2439  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2440 
2441  tester.Responding(false);
2442 
2443  // Release F
2444  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2445  WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2446  /* overwrite_prev_state_0 */ true}
2447  .Build(kWmResultZero)});
2448 
2449  EXPECT_EQ(tester.key_calls.size(), 1);
2450  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
2451  kNotSynthesized);
2452  tester.clear_key_calls();
2453  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2454 }

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

Referenced by TEST_F().

Variable Documentation

◆ kScanCodeKeyA

constexpr uint64_t flutter::testing::kScanCodeKeyA = 0x1e
constexpr

Definition at line 41 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 42 of file flutter_windows_view_unittests.cc.

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

flutter::testing::VietnameseTelexAddDiacriticWithSlowResponse
void VietnameseTelexAddDiacriticWithSlowResponse(WindowsTestContext &context, bool backspace_response)
Definition: keyboard_unittests.cc:2349
flutter::testing::CreateSemanticsNode
FlutterSemanticsNode2 CreateSemanticsNode(int32_t id, const char *label, const std::vector< int32_t > *children=nullptr)
Definition: accessibility_bridge_unittests.cc:18
flutter::kImplicitViewId
constexpr FlutterViewId kImplicitViewId
Definition: flutter_windows_engine.h:54
flutter::WindowStateEvent
WindowStateEvent
An event representing a change in window state that may update the.
Definition: windows_lifecycle_manager.h:24
FlutterDesktopViewGetHWND
HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view)
Definition: flutter_windows.cc:241
FlutterDesktopViewControllerGetView
FlutterDesktopViewRef FlutterDesktopViewControllerGetView(FlutterDesktopViewControllerRef ref)
Definition: flutter_windows.cc:148
FlutterDesktopEngineGetTextureRegistrar
FlutterDesktopTextureRegistrarRef FlutterDesktopEngineGetTextureRegistrar(FlutterDesktopEngineRef engine)
Definition: flutter_windows.cc:228
FlutterDesktopPluginRegistrarGetView
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(FlutterDesktopPluginRegistrarRef registrar)
Definition: flutter_windows.cc:285
hook_history
std::list< KeyboardHookCall > * hook_history
Definition: keyboard_key_handler_unittests.cc:171
scancode
int scancode
Definition: keyboard_key_handler_unittests.cc:115
user_data
void * user_data
Definition: keyboard_key_embedder_handler_unittests.cc:48
FlutterDesktopEngineProperties
Definition: flutter_windows.h:39
kFlutterDesktopGpuSurfaceTexture
@ kFlutterDesktopGpuSurfaceTexture
Definition: flutter_texture_registrar.h:28
was_down
bool was_down
Definition: keyboard_key_handler_unittests.cc:119
extended
bool extended
Definition: keyboard_key_handler_unittests.cc:118
flutter::GetPreferredLanguageInfo
std::vector< LanguageInfo > GetPreferredLanguageInfo(const WindowsProcTable &windows_proc_table)
Definition: system_utils.cc:15
FlutterDesktopBinaryReply
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
Definition: flutter_messenger.h:26
FlutterDesktopViewId
int64_t FlutterDesktopViewId
Definition: flutter_windows.h:36
flutter::GetDpiForMonitor
UINT GetDpiForMonitor(HMONITOR monitor)
Definition: dpi_utils.cc:134
user_data
void * user_data
Definition: flutter_windows_view_unittests.cc:52
FlutterDesktopPixelBuffer
Definition: flutter_texture_registrar.h:56
kDeleteCustomCursorMethod
static constexpr char kDeleteCustomCursorMethod[]
Definition: cursor_handler.cc:42
character
char32_t character
Definition: keyboard_key_handler_unittests.cc:117
kUpdateEditingStateMethod
static constexpr char kUpdateEditingStateMethod[]
Definition: text_input_plugin.cc:28
PlatformViewId
int64_t PlatformViewId
Definition: flutter_windows_internal.h:42
FlutterDesktopEngineProperties::dart_entrypoint_argv
const char ** dart_entrypoint_argv
Definition: flutter_windows.h:69
flutter::EncodeUtf16
std::u16string EncodeUtf16(char32_t character)
Definition: keyboard_utils.cc:11
FlutterDesktopViewControllerProperties
Definition: flutter_windows_internal.h:18
FlutterDesktopPixelBufferTextureConfig::user_data
void * user_data
Definition: flutter_texture_registrar.h:134
FlutterDesktopGpuSurfaceDescriptor::visible_width
size_t visible_width
Definition: flutter_texture_registrar.h:93
kSetCustomCursorMethod
static constexpr char kSetCustomCursorMethod[]
Definition: cursor_handler.cc:38
EXPECT_CALL_IS_TEXT
#define EXPECT_CALL_IS_TEXT(_key_call, u16_string)
Definition: keyboard_unittests.cc:560
flutter::kScanCodeShiftLeft
constexpr int kScanCodeShiftLeft
Definition: keyboard_utils.h:16
FlutterDesktopEngineProperties::icu_data_path
const wchar_t * icu_data_path
Definition: flutter_windows.h:48
FlutterDesktopEngineGetPluginRegistrar
FlutterDesktopPluginRegistrarRef FlutterDesktopEngineGetPluginRegistrar(FlutterDesktopEngineRef engine, const char *plugin_name)
Definition: flutter_windows.cc:213
flutter::GetDpiForHWND
UINT GetDpiForHWND(HWND hwnd)
Definition: dpi_utils.cc:130
flutter::GetUserTimeFormat
std::wstring GetUserTimeFormat()
Definition: system_utils.cc:101
user_data
void * user_data
Definition: keyboard_key_handler_unittests.cc:56
FlutterDesktopGpuSurfaceTextureConfig::user_data
void * user_data
Definition: flutter_texture_registrar.h:148
type
enum flutter::testing::@87::KeyboardChange::Type type
flutter::Prefer24HourTime
bool Prefer24HourTime(std::wstring time_format)
Definition: system_utils.cc:113
FlutterDesktopPixelBufferTextureConfig::callback
FlutterDesktopPixelBufferTextureCallback callback
Definition: flutter_texture_registrar.h:132
kEnableDeltaModel
static constexpr char kEnableDeltaModel[]
Definition: text_input_plugin.cc:39
FlutterDesktopTextureType
FlutterDesktopTextureType
Definition: flutter_texture_registrar.h:24
FlutterDesktopGpuSurfaceDescriptor::release_callback
void(* release_callback)(void *release_context)
Definition: flutter_texture_registrar.h:100
kSelectionExtentKey
static constexpr char kSelectionExtentKey[]
Definition: text_input_plugin.cc:48
FlutterDesktopViewControllerGetViewId
FlutterDesktopViewId FlutterDesktopViewControllerGetViewId(FlutterDesktopViewControllerRef ref)
Definition: flutter_windows.cc:136
kActivateSystemCursorMethod
static constexpr char kActivateSystemCursorMethod[]
Definition: cursor_handler.cc:15
flutter::ParseLanguageName
LanguageInfo ParseLanguageName(std::wstring language_name)
Definition: system_utils.cc:71
text
std::u16string text
Definition: keyboard_unittests.cc:332
FlutterDesktopViewRef
struct FlutterDesktopView * FlutterDesktopViewRef
Definition: flutter_windows.h:29
FlutterDesktopEngineRef
struct FlutterDesktopEngine * FlutterDesktopEngineRef
Definition: flutter_windows.h:33
FlutterDesktopTextureInfo::type
FlutterDesktopTextureType type
Definition: flutter_texture_registrar.h:152
FlutterDesktopGpuSurfaceDescriptor::visible_height
size_t visible_height
Definition: flutter_texture_registrar.h:96
FlutterDesktopGpuSurfaceDescriptor::release_context
void * release_context
Definition: flutter_texture_registrar.h:102
flutter::testing::kScanCodeKeyA
constexpr uint64_t kScanCodeKeyA
Definition: flutter_windows_view_unittests.cc:41
FlutterDesktopGpuSurfaceTextureConfig::struct_size
size_t struct_size
Definition: flutter_texture_registrar.h:141
FlutterDesktopTextureInfo::pixel_buffer_config
FlutterDesktopPixelBufferTextureConfig pixel_buffer_config
Definition: flutter_texture_registrar.h:154
FlutterDesktopGpuSurfaceDescriptor::height
size_t height
Definition: flutter_texture_registrar.h:90
flutter::BinaryReply
std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
Definition: binary_messenger.h:17
FlutterDesktopGpuSurfaceTextureConfig::type
FlutterDesktopGpuSurfaceType type
Definition: flutter_texture_registrar.h:144
FlutterDesktopTextureInfo
Definition: flutter_texture_registrar.h:151
flutter::ConvertChar32ToUtf8
std::string ConvertChar32ToUtf8(char32_t ch)
Definition: keyboard_key_embedder_handler.cc:38
FlutterDesktopGpuSurfaceTextureConfig::callback
FlutterDesktopGpuSurfaceTextureCallback callback
Definition: flutter_texture_registrar.h:146
flutter::FlutterViewId
int64_t FlutterViewId
Definition: flutter_view.h:13
kErrorSuccess
static constexpr int kErrorSuccess
Definition: platform_handler.cc:45
FlutterDesktopPixelBuffer::release_context
void * release_context
Definition: flutter_texture_registrar.h:66
kSelectionBaseKey
static constexpr char kSelectionBaseKey[]
Definition: text_input_plugin.cc:47
FlutterDesktopGpuSurfaceDescriptor
Definition: flutter_texture_registrar.h:70
EXPECT_CALL_IS_TEXT_METHOD_CALL
#define EXPECT_CALL_IS_TEXT_METHOD_CALL(_key_call, json_string)
Definition: keyboard_unittests.cc:564
flutter::kShift
constexpr int kShift
Definition: keyboard_utils.h:14
kFlutterDesktopGpuSurfaceTypeD3d11Texture2D
@ kFlutterDesktopGpuSurfaceTypeD3d11Texture2D
Definition: flutter_texture_registrar.h:40
FlutterDesktopViewControllerCreate
FlutterDesktopViewControllerRef FlutterDesktopViewControllerCreate(int width, int height, FlutterDesktopEngineRef engine)
Definition: flutter_windows.cc:117
FlutterDesktopTextureInfo::gpu_surface_config
FlutterDesktopGpuSurfaceTextureConfig gpu_surface_config
Definition: flutter_texture_registrar.h:155
FlutterDesktopPixelBuffer::buffer
const uint8_t * buffer
Definition: flutter_texture_registrar.h:58
kCreateCustomCursorMethod
static constexpr char kCreateCustomCursorMethod[]
Definition: cursor_handler.cc:20
kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle
@ kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle
Definition: flutter_texture_registrar.h:38
kSetClientMethod
static constexpr char kSetClientMethod[]
Definition: text_input_plugin.cc:19
kChannelName
static constexpr char kChannelName[]
Definition: cursor_handler.cc:13
callback
FlutterKeyEventCallback callback
Definition: keyboard_key_handler_unittests.cc:55
EXPECT_CALL_IS_EVENT
#define EXPECT_CALL_IS_EVENT(_key_call, _type, _physical, _logical, _character, _synthesized)
Definition: keyboard_unittests.cc:554
FlutterDesktopEngineDestroy
bool FlutterDesktopEngineDestroy(FlutterDesktopEngineRef engine_ref)
Definition: flutter_windows.cc:185
flutter::kScanCodeControlLeft
constexpr int kScanCodeControlLeft
Definition: keyboard_utils.h:19
content
union flutter::testing::@87::KeyboardChange::@0 content
FlutterDesktopEngineCreate
FlutterDesktopEngineRef FlutterDesktopEngineCreate(const FlutterDesktopEngineProperties *engine_properties)
Definition: flutter_windows.cc:178
FlutterDesktopViewControllerGetEngine
FlutterDesktopEngineRef FlutterDesktopViewControllerGetEngine(FlutterDesktopViewControllerRef ref)
Definition: flutter_windows.cc:142
FlutterDesktopGpuSurfaceDescriptor::handle
void * handle
Definition: flutter_texture_registrar.h:86
callback
FlutterKeyEventCallback callback
Definition: keyboard_key_embedder_handler_unittests.cc:47
FlutterDesktopGpuSurfaceTextureConfig
Definition: flutter_texture_registrar.h:138
FlutterDesktopEngineProperties::dart_entrypoint_argc
int dart_entrypoint_argc
Definition: flutter_windows.h:65
FlutterDesktopPixelBuffer::width
size_t width
Definition: flutter_texture_registrar.h:60
message
Win32Message message
Definition: keyboard_unittests.cc:137
action
int action
Definition: keyboard_key_handler_unittests.cc:116
flutter::kScanCodeControlRight
constexpr int kScanCodeControlRight
Definition: keyboard_utils.h:20
flutter::AppLifecycleState
AppLifecycleState
Definition: app_lifecycle_state.h:32
FlutterDesktopEngineSetNextFrameCallback
void FlutterDesktopEngineSetNextFrameCallback(FlutterDesktopEngineRef engine, VoidCallback callback, void *user_data)
Definition: flutter_windows.cc:234
FlutterDesktopEngineCreateViewController
FlutterDesktopViewControllerRef FlutterDesktopEngineCreateViewController(FlutterDesktopEngineRef engine, const FlutterDesktopViewControllerProperties *properties)
Definition: flutter_windows.cc:124
kAccessDeniedErrorCode
static constexpr int kAccessDeniedErrorCode
Definition: platform_handler.cc:44
flutter::kControl
constexpr int kControl
Definition: keyboard_utils.h:15
flutter::kScanCodeShiftRight
constexpr int kScanCodeShiftRight
Definition: keyboard_utils.h:17
FlutterDesktopPixelBuffer::release_callback
void(* release_callback)(void *release_context)
Definition: flutter_texture_registrar.h:64
FlutterDesktopGpuSurfaceDescriptor::struct_size
size_t struct_size
Definition: flutter_texture_registrar.h:73
FlutterDesktopViewGetGraphicsAdapter
IDXGIAdapter * FlutterDesktopViewGetGraphicsAdapter(FlutterDesktopViewRef view)
Definition: flutter_windows.cc:245
flutter::EncodableMap
std::map< EncodableValue, EncodableValue > EncodableMap
Definition: encodable_value.h:95
FlutterDesktopEngineProperties::assets_path
const wchar_t * assets_path
Definition: flutter_windows.h:43
key
int key
Definition: keyboard_key_handler_unittests.cc:114
FlutterDesktopGpuSurfaceDescriptor::width
size_t width
Definition: flutter_texture_registrar.h:88
FlutterDesktopPluginRegistrar
Definition: window_state.h:23
FlutterDesktopEngineRun
bool FlutterDesktopEngineRun(FlutterDesktopEngineRef engine, const char *entry_point)
Definition: flutter_windows.cc:195
kFlutterDesktopPixelBufferTexture
@ kFlutterDesktopPixelBufferTexture
Definition: flutter_texture_registrar.h:26
flutter::testing::kVirtualKeyA
constexpr uint64_t kVirtualKeyA
Definition: flutter_windows_view_unittests.cc:42
FlutterDesktopPixelBuffer::height
size_t height
Definition: flutter_texture_registrar.h:62
flutter::WindowsPlatformThreadPrioritySetter
static void WindowsPlatformThreadPrioritySetter(FlutterThreadPriority priority)
Definition: flutter_windows_engine.h:59
texture_id
uint32_t texture_id
Definition: compositor_opengl.cc:20
FlutterDesktopPluginRegistrarGetViewById
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopViewId view_id)
Definition: flutter_windows.cc:290
flutter::GetPreferredLanguages
std::vector< std::wstring > GetPreferredLanguages(const WindowsProcTable &windows_proc_table)
Definition: system_utils.cc:45
callback
FlutterDesktopBinaryReply callback
Definition: flutter_windows_view_unittests.cc:51
node_delegate
std::shared_ptr< FlutterPlatformNodeDelegateWindows > node_delegate
Definition: accessibility_bridge_windows_unittests.cc:33