mouse-input-test.cc

Go to the documentation of this file.

// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include <fuchsia/accessibility/semantics/cpp/fidl.h>
#include <fuchsia/buildinfo/cpp/fidl.h>
#include <fuchsia/component/cpp/fidl.h>
#include <fuchsia/fonts/cpp/fidl.h>
#include <fuchsia/input/report/cpp/fidl.h>
#include <fuchsia/kernel/cpp/fidl.h>
#include <fuchsia/logger/cpp/fidl.h>
#include <fuchsia/memorypressure/cpp/fidl.h>
#include <fuchsia/metrics/cpp/fidl.h>
#include <fuchsia/net/interfaces/cpp/fidl.h>
#include <fuchsia/tracing/provider/cpp/fidl.h>
#include <fuchsia/ui/app/cpp/fidl.h>
#include <fuchsia/ui/display/singleton/cpp/fidl.h>
#include <fuchsia/ui/input/cpp/fidl.h>
#include <fuchsia/ui/test/input/cpp/fidl.h>
#include <fuchsia/web/cpp/fidl.h>
#include <lib/async/cpp/task.h>
#include <lib/fidl/cpp/binding_set.h>
#include <lib/sys/component/cpp/testing/realm_builder.h>
#include <lib/sys/component/cpp/testing/realm_builder_types.h>
#include <zircon/status.h>
#include <zircon/types.h>
#include <zircon/utc.h>
 
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <memory>
#include <optional>
#include <queue>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <gtest/gtest.h>
 
#include "flutter/fml/logging.h"
#include "flutter/shell/platform/fuchsia/flutter/tests/integration/utils/portable_ui_test.h"
#include "lib/fidl/cpp/interface_ptr.h"
 
namespace mouse_input_test::testing {
namespace {
// Types imported for the realm_builder library.
using component_testing::ChildRef;
using component_testing::ConfigValue;
using component_testing::LocalComponentImpl;
using component_testing::ParentRef;
using component_testing::Protocol;
using component_testing::Realm;
using component_testing::Route;
 
using fuchsia_test_utils::PortableUITest;
using RealmBuilder = component_testing::RealmBuilder;
 
// Alias for Component child name as provided to Realm Builder.
using ChildName = std::string;
 
// Alias for Component Legacy URL as provided to Realm Builder.
using LegacyUrl = std::string;
 
// Maximum pointer movement during a clickpad press for the gesture to
// be guaranteed to be interpreted as a click. For movement greater than
// this value, upper layers may, e.g., interpret the gesture as a drag.
//
// This value corresponds to the one used to instantiate the ClickDragHandler
// registered by Input Pipeline in Scene Manager.
constexpr int64_t kClickToDragThreshold = 16.0;
 
constexpr auto kMouseInputListener = "mouse_input_listener";
constexpr auto kMouseInputListenerRef = ChildRef{kMouseInputListener};
constexpr auto kMouseInputView = "mouse-input-view";
constexpr auto kMouseInputViewRef = ChildRef{kMouseInputView};
constexpr auto kMouseInputViewUrl =
    "fuchsia-pkg://fuchsia.com/mouse-input-view#meta/mouse-input-view.cm";
 
struct Position {
  double x = 0.0;
  double y = 0.0;
};
 
// Combines all vectors in `vecs` into one.
template <typename T>
std::vector<T> merge(std::initializer_list<std::vector<T>> vecs) {
  std::vector<T> result;
  for (auto v : vecs) {
    result.insert(result.end(), v.begin(), v.end());
  }
  return result;
}
 
int ButtonsToInt(
    const std::vector<fuchsia::ui::test::input::MouseButton>& buttons) {
  int result = 0;
  for (const auto& button : buttons) {
    result |= (0x1 >> button);
  }
 
  return result;
}
 
// `MouseInputListener` is a local test protocol that our test apps use to let
// us know what position and button press state the mouse cursor has.
class MouseInputListenerServer
    : public fuchsia::ui::test::input::MouseInputListener,
      public LocalComponentImpl {
 public:
  explicit MouseInputListenerServer(async_dispatcher_t* dispatcher)
      : dispatcher_(dispatcher) {}
 
  void ReportMouseInput(
      fuchsia::ui::test::input::MouseInputListenerReportMouseInputRequest
          request) override {
    FML_LOG(INFO) << "Received MouseInput event";
    events_.push(std::move(request));
  }
 
  // |MockComponent::OnStart|
  // When the component framework requests for this component to start, this
  // method will be invoked by the realm_builder library.
  void OnStart() override {
    FML_LOG(INFO) << "Starting MouseInputServer";
    ASSERT_EQ(ZX_OK, outgoing()->AddPublicService(
                         fidl::InterfaceRequestHandler<
                             fuchsia::ui::test::input::MouseInputListener>(
                             [this](auto request) {
                               bindings_.AddBinding(this, std::move(request),
                                                    dispatcher_);
                             })));
  }
 
  size_t SizeOfEvents() const { return events_.size(); }
 
  fuchsia::ui::test::input::MouseInputListenerReportMouseInputRequest
  PopEvent() {
    auto e = std::move(events_.front());
    events_.pop();
    return e;
  }
 
  const fuchsia::ui::test::input::MouseInputListenerReportMouseInputRequest&
  LastEvent() const {
    return events_.back();
  }
 
  void ClearEvents() { events_ = {}; }
 
 private:
  // Not owned.
  async_dispatcher_t* dispatcher_ = nullptr;
  fidl::BindingSet<fuchsia::ui::test::input::MouseInputListener> bindings_;
  std::queue<
      fuchsia::ui::test::input::MouseInputListenerReportMouseInputRequest>
      events_;
};
 
class MouseInputTest : public PortableUITest,
                       public ::testing::Test,
                       public ::testing::WithParamInterface<std::string> {
 protected:
  void SetUp() override {
    PortableUITest::SetUp();
 
    // Register fake mouse device.
    RegisterMouse();
 
    // Get the display dimensions.
    FML_LOG(INFO)
        << "Waiting for display info from fuchsia.ui.display.singleton.Info";
    fuchsia::ui::display::singleton::InfoPtr display_info =
        realm_root()
            ->component()
            .Connect<fuchsia::ui::display::singleton::Info>();
    display_info->GetMetrics(
        [this](fuchsia::ui::display::singleton::Metrics metrics) {
          display_width_ = metrics.extent_in_px().width;
          display_height_ = metrics.extent_in_px().height;
          FML_LOG(INFO) << "Got display_width = " << display_width_
                        << " and display_height = " << display_height_;
        });
    RunLoopUntil(
        [this] { return display_width_ != 0 && display_height_ != 0; });
  }
 
  void TearDown() override {
    // at the end of test, ensure event queue is empty.
    ASSERT_EQ(mouse_input_listener_->SizeOfEvents(), 0u);
  }
 
  MouseInputListenerServer* mouse_input_listener() {
    return mouse_input_listener_;
  }
 
  // Helper method for checking the test.mouse.MouseInputListener response from
  // the client app.
  void VerifyEvent(
      fuchsia::ui::test::input::MouseInputListenerReportMouseInputRequest&
          pointer_data,
      double expected_x,
      double expected_y,
      std::vector<fuchsia::ui::test::input::MouseButton> expected_buttons,
      const fuchsia::ui::test::input::MouseEventPhase expected_phase,
      const std::string& component_name) {
    FML_LOG(INFO) << "Client received mouse change at ("
                  << pointer_data.local_x() << ", " << pointer_data.local_y()
                  << ") with buttons " << ButtonsToInt(pointer_data.buttons())
                  << ".";
    FML_LOG(INFO) << "Expected mouse change is at approximately (" << expected_x
                  << ", " << expected_y << ") with buttons "
                  << ButtonsToInt(expected_buttons) << ".";
 
    // Allow for minor rounding differences in coordinates.
    // Note: These approximations don't account for
    // `PointerMotionDisplayScaleHandler` or `PointerMotionSensorScaleHandler`.
    // We will need to do so in order to validate larger motion or different
    // sized displays.
    EXPECT_NEAR(pointer_data.local_x(), expected_x, 1);
    EXPECT_NEAR(pointer_data.local_y(), expected_y, 1);
    EXPECT_EQ(pointer_data.buttons(), expected_buttons);
    EXPECT_EQ(pointer_data.phase(), expected_phase);
    EXPECT_EQ(pointer_data.component_name(), component_name);
  }
 
  void VerifyEventLocationOnTheRightOfExpectation(
      fuchsia::ui::test::input::MouseInputListenerReportMouseInputRequest&
          pointer_data,
      double expected_x_min,
      double expected_y,
      std::vector<fuchsia::ui::test::input::MouseButton> expected_buttons,
      const fuchsia::ui::test::input::MouseEventPhase expected_phase,
      const std::string& component_name) {
    FML_LOG(INFO) << "Client received mouse change at ("
                  << pointer_data.local_x() << ", " << pointer_data.local_y()
                  << ") with buttons " << ButtonsToInt(pointer_data.buttons())
                  << ".";
    FML_LOG(INFO) << "Expected mouse change is at approximately (>"
                  << expected_x_min << ", " << expected_y << ") with buttons "
                  << ButtonsToInt(expected_buttons) << ".";
 
    EXPECT_GT(pointer_data.local_x(), expected_x_min);
    EXPECT_NEAR(pointer_data.local_y(), expected_y, 1);
    EXPECT_EQ(pointer_data.buttons(), expected_buttons);
    EXPECT_EQ(pointer_data.phase(), expected_phase);
    EXPECT_EQ(pointer_data.component_name(), component_name);
  }
 
  // Guaranteed to be initialized after SetUp().
  uint32_t display_width() const { return display_width_; }
  uint32_t display_height() const { return display_height_; }
 
 private:
  void ExtendRealm() override {
    FML_LOG(INFO) << "Extending realm";
 
    // Key part of service setup: have this test component vend the
    // |MouseInputListener| service in the constructed realm.
    auto mouse_input_listener =
        std::make_unique<MouseInputListenerServer>(dispatcher());
    mouse_input_listener_ = mouse_input_listener.get();
    realm_builder()->AddLocalChild(
        kMouseInputListener,
        [mouse_input_listener = std::move(mouse_input_listener)]() mutable {
          return std::move(mouse_input_listener);
        });
 
    realm_builder()->AddChild(kMouseInputView, kMouseInputViewUrl,
                              component_testing::ChildOptions{
                                  .environment = kFlutterRunnerEnvironment,
                              });
 
    realm_builder()->AddRoute(
        Route{.capabilities = {Protocol{
                  fuchsia::ui::test::input::MouseInputListener::Name_}},
              .source = kMouseInputListenerRef,
              .targets = {kFlutterJitRunnerRef, kMouseInputViewRef}});
 
    realm_builder()->AddRoute(
        Route{.capabilities = {Protocol{fuchsia::ui::app::ViewProvider::Name_}},
              .source = kMouseInputViewRef,
              .targets = {ParentRef()}});
  }
 
  ParamType GetTestUIStackUrl() override { return GetParam(); };
 
  MouseInputListenerServer* mouse_input_listener_;
 
  uint32_t display_width_ = 0;
  uint32_t display_height_ = 0;
};
 
// Makes use of gtest's parameterized testing, allowing us
// to test different combinations of test-ui-stack + runners. Currently, there
// is just one combination. Documentation:
// http://go/gunitadvanced#value-parameterized-tests
INSTANTIATE_TEST_SUITE_P(
    MouseInputTestParameterized,
    MouseInputTest,
    ::testing::Values(
        "fuchsia-pkg://fuchsia.com/flatland-scene-manager-test-ui-stack#meta/"
        "test-ui-stack.cm"));
 
TEST_P(MouseInputTest, DISABLED_FlutterMouseMove) {
  LaunchClient();
 
  SimulateMouseEvent(/* pressed_buttons = */ {}, /* movement_x = */ 1,
                     /* movement_y = */ 2);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 1u);
 
  auto e = mouse_input_listener()->PopEvent();
 
  // If the first mouse event is cursor movement, Flutter first sends an ADD
  // event with updated location.
  VerifyEvent(e,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f + 1,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f + 2,
              /*expected_buttons=*/{},
              /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::ADD,
              /*component_name=*/"mouse-input-view");
}
 
TEST_P(MouseInputTest, DISABLED_FlutterMouseDown) {
  LaunchClient();
 
  SimulateMouseEvent(
      /* pressed_buttons = */ {fuchsia::ui::test::input::MouseButton::FIRST},
      /* movement_x = */ 0, /* movement_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 3; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 3u);
 
  auto event_add = mouse_input_listener()->PopEvent();
  auto event_down = mouse_input_listener()->PopEvent();
  auto event_noop_move = mouse_input_listener()->PopEvent();
 
  // If the first mouse event is a button press, Flutter first sends an ADD
  // event with no buttons.
  VerifyEvent(event_add,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/{},
              /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::ADD,
              /*component_name=*/"mouse-input-view");
 
  // Then Flutter sends a DOWN pointer event with the buttons we care about.
  VerifyEvent(
      event_down,
      /*expected_x=*/static_cast<double>(display_width()) / 2.f,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::DOWN,
      /*component_name=*/"mouse-input-view");
 
  // Then Flutter sends a MOVE pointer event with no new information.
  VerifyEvent(
      event_noop_move,
      /*expected_x=*/static_cast<double>(display_width()) / 2.f,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::MOVE,
      /*component_name=*/"mouse-input-view");
}
 
TEST_P(MouseInputTest, DISABLED_FlutterMouseDownUp) {
  LaunchClient();
 
  SimulateMouseEvent(
      /* pressed_buttons = */ {fuchsia::ui::test::input::MouseButton::FIRST},
      /* movement_x = */ 0, /* movement_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 3; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 3u);
 
  auto event_add = mouse_input_listener()->PopEvent();
  auto event_down = mouse_input_listener()->PopEvent();
  auto event_noop_move = mouse_input_listener()->PopEvent();
 
  // If the first mouse event is a button press, Flutter first sends an ADD
  // event with no buttons.
  VerifyEvent(event_add,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/{},
              /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::ADD,
              /*component_name=*/"mouse-input-view");
 
  // Then Flutter sends a DOWN pointer event with the buttons we care about.
  VerifyEvent(
      event_down,
      /*expected_x=*/static_cast<double>(display_width()) / 2.f,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::DOWN,
      /*component_name=*/"mouse-input-view");
 
  // Then Flutter sends a MOVE pointer event with no new information.
  VerifyEvent(
      event_noop_move,
      /*expected_x=*/static_cast<double>(display_width()) / 2.f,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::MOVE,
      /*component_name=*/"mouse-input-view");
 
  SimulateMouseEvent(/* pressed_buttons = */ {}, /* movement_x = */ 0,
                     /* movement_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 1u);
 
  auto event_up = mouse_input_listener()->PopEvent();
  VerifyEvent(event_up,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/{},
              /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::UP,
              /*component_name=*/"mouse-input-view");
}
 
TEST_P(MouseInputTest, DISABLED_FlutterMouseDownMoveUp) {
  LaunchClient();
 
  SimulateMouseEvent(
      /* pressed_buttons = */ {fuchsia::ui::test::input::MouseButton::FIRST},
      /* movement_x = */ 0, /* movement_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 3; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 3u);
 
  auto event_add = mouse_input_listener()->PopEvent();
  auto event_down = mouse_input_listener()->PopEvent();
  auto event_noop_move = mouse_input_listener()->PopEvent();
 
  // If the first mouse event is a button press, Flutter first sends an ADD
  // event with no buttons.
  VerifyEvent(event_add,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/{},
              /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::ADD,
              /*component_name=*/"mouse-input-view");
 
  // Then Flutter sends a DOWN pointer event with the buttons we care about.
  VerifyEvent(
      event_down,
      /*expected_x=*/static_cast<double>(display_width()) / 2.f,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::DOWN,
      /*component_name=*/"mouse-input-view");
 
  // Then Flutter sends a MOVE pointer event with no new information.
  VerifyEvent(
      event_noop_move,
      /*expected_x=*/static_cast<double>(display_width()) / 2.f,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::MOVE,
      /*component_name=*/"mouse-input-view");
 
  SimulateMouseEvent(
      /* pressed_buttons = */ {fuchsia::ui::test::input::MouseButton::FIRST},
      /* movement_x = */ kClickToDragThreshold, /* movement_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 1u);
 
  auto event_move = mouse_input_listener()->PopEvent();
 
  VerifyEventLocationOnTheRightOfExpectation(
      event_move,
      /*expected_x_min=*/static_cast<double>(display_width()) / 2.f + 1,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{fuchsia::ui::test::input::MouseButton::FIRST},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::MOVE,
      /*component_name=*/"mouse-input-view");
 
  SimulateMouseEvent(/* pressed_buttons = */ {}, /* movement_x = */ 0,
                     /* movement_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  ASSERT_EQ(mouse_input_listener()->SizeOfEvents(), 1u);
 
  auto event_up = mouse_input_listener()->PopEvent();
 
  VerifyEventLocationOnTheRightOfExpectation(
      event_up,
      /*expected_x_min=*/static_cast<double>(display_width()) / 2.f + 1,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/{},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::UP,
      /*component_name=*/"mouse-input-view");
}
 
// TODO(fxbug.dev/103098): This test shows the issue when sending mouse wheel as
// the first event to Flutter.
// 1. expect Flutter app receive 2 events: ADD - Scroll, but got 3 events: Move
// - Scroll - Scroll.
// 2. the first event flutter app received has random value in buttons field
// Disabled until flutter rolls, since it changes the behavior of this issue.
TEST_P(MouseInputTest, DISABLED_FlutterMouseWheelIssue103098) {
  LaunchClient();
 
  SimulateMouseScroll(/* pressed_buttons = */ {}, /* scroll_x = */ 1,
                      /* scroll_y = */ 0);
  // Here we expected 2 events, ADD - Scroll, but got 3, Move - Scroll - Scroll.
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 3; });
 
  double initial_x = static_cast<double>(display_width()) / 2.f;
  double initial_y = static_cast<double>(display_height()) / 2.f;
 
  auto event_1 = mouse_input_listener()->PopEvent();
  EXPECT_NEAR(event_1.local_x(), initial_x, 1);
  EXPECT_NEAR(event_1.local_y(), initial_y, 1);
  // Flutter will scale the count of ticks to pixel.
  EXPECT_GT(event_1.wheel_x_physical_pixel(), 0);
  EXPECT_EQ(event_1.wheel_y_physical_pixel(), 0);
  EXPECT_EQ(event_1.phase(), fuchsia::ui::test::input::MouseEventPhase::MOVE);
 
  auto event_2 = mouse_input_listener()->PopEvent();
  VerifyEvent(
      event_2,
      /*expected_x=*/initial_x,
      /*expected_y=*/initial_y,
      /*expected_buttons=*/{},
      /*expected_phase=*/fuchsia::ui::test::input::MouseEventPhase::HOVER,
      /*component_name=*/"mouse-input-view");
  // Flutter will scale the count of ticks to pixel.
  EXPECT_GT(event_2.wheel_x_physical_pixel(), 0);
  EXPECT_EQ(event_2.wheel_y_physical_pixel(), 0);
 
  auto event_3 = mouse_input_listener()->PopEvent();
  VerifyEvent(
      event_3,
      /*expected_x=*/initial_x,
      /*expected_y=*/initial_y,
      /*expected_buttons=*/{},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::HOVER,
      /*component_name=*/"mouse-input-view");
  // Flutter will scale the count of ticks to pixel.
  EXPECT_GT(event_3.wheel_x_physical_pixel(), 0);
  EXPECT_EQ(event_3.wheel_y_physical_pixel(), 0);
}
 
TEST_P(MouseInputTest, DISABLED_FlutterMouseWheel) {
  LaunchClient();
 
  double initial_x = static_cast<double>(display_width()) / 2.f + 1;
  double initial_y = static_cast<double>(display_height()) / 2.f + 2;
 
  // TODO(fxbug.dev/103098): Send a mouse move as the first event to workaround.
  SimulateMouseEvent(/* pressed_buttons = */ {},
                     /* movement_x = */ 1, /* movement_y = */ 2);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  auto event_add = mouse_input_listener()->PopEvent();
  VerifyEvent(event_add,
              /*expected_x=*/initial_x,
              /*expected_y=*/initial_y,
              /*expected_buttons=*/{},
              /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::ADD,
              /*component_name=*/"mouse-input-view");
 
  SimulateMouseScroll(/* pressed_buttons = */ {}, /* scroll_x = */ 1,
                      /* scroll_y = */ 0);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  auto event_wheel_h = mouse_input_listener()->PopEvent();
 
  VerifyEvent(
      event_wheel_h,
      /*expected_x=*/initial_x,
      /*expected_y=*/initial_y,
      /*expected_buttons=*/{},
      /*expected_phase=*/fuchsia::ui::test::input::MouseEventPhase::HOVER,
      /*component_name=*/"mouse-input-view");
  // Flutter will scale the count of ticks to pixel.
  EXPECT_GT(event_wheel_h.wheel_x_physical_pixel(), 0);
  EXPECT_EQ(event_wheel_h.wheel_y_physical_pixel(), 0);
 
  SimulateMouseScroll(/* pressed_buttons = */ {}, /* scroll_x = */ 0,
                      /* scroll_y = */ 1);
  RunLoopUntil(
      [this] { return this->mouse_input_listener()->SizeOfEvents() == 1; });
 
  auto event_wheel_v = mouse_input_listener()->PopEvent();
 
  VerifyEvent(
      event_wheel_v,
      /*expected_x=*/initial_x,
      /*expected_y=*/initial_y,
      /*expected_buttons=*/{},
      /*expected_type=*/fuchsia::ui::test::input::MouseEventPhase::HOVER,
      /*component_name=*/"mouse-input-view");
  // Flutter will scale the count of ticks to pixel.
  EXPECT_LT(event_wheel_v.wheel_y_physical_pixel(), 0);
  EXPECT_EQ(event_wheel_v.wheel_x_physical_pixel(), 0);
}
 
}  // namespace
}  // namespace mouse_input_test::testing