| // Copyright 2023 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "sommelier-gaming.cc" // NOLINT |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #include <wayland-client.h> |
| #include <wayland-client-protocol.h> |
| #include <wayland-server-core.h> |
| #include <wayland-server-protocol.h> |
| #include <wayland-util.h> |
| |
| #include "libevdev/mock-libevdev-shim.h" |
| #include "testing/x11-test-base.h" |
| |
| namespace vm_tools { |
| namespace sommelier { |
| |
| class GamepadTest : public X11TestBase { |
| public: |
| void Connect() override { |
| X11TestBase::Connect(); |
| |
| Libevdev::Set(&libevdevshim); |
| } |
| |
| protected: |
| // Normally a zcr_gamepad_v2 is generated and sent by the server. We don't |
| // have an easy way to do this client side and need to create it ourselves via |
| // this hack. |
| struct zcr_gamepad_v2* CreateGamepadProxy( |
| struct zcr_gaming_seat_v2* gaming_seat) { |
| return reinterpret_cast<zcr_gamepad_v2*>(wl_proxy_create( |
| reinterpret_cast<wl_proxy*>(gaming_seat), &zcr_gamepad_v2_interface)); |
| } |
| |
| std::vector<struct sl_host_gamepad*> GetHostGamepads(struct sl_context* ctx) { |
| std::vector<struct sl_host_gamepad*> host_gamepads; |
| struct sl_host_gamepad* it; |
| wl_list_for_each(it, &(ctx->gamepads), link) { |
| host_gamepads.push_back(it); |
| } |
| return host_gamepads; |
| } |
| |
| void BindWLSeat(struct sl_context* ctx) { |
| xwayland.get()->BindToWlSeats(ctx); |
| Pump(); |
| } |
| |
| // Helper function that sets up a gamepad_with_info successfully. |
| void SetupGamepad(struct sl_context* ctx, |
| struct zcr_gamepad_v2*& gamepad, |
| struct libevdev*& ev_dev, |
| const char* name, |
| uint32_t bus, |
| uint32_t vendor_id, |
| uint32_t product_id, |
| uint32_t version) { |
| BindWLSeat(ctx); |
| gamepad = CreateGamepadProxy(ctx->gaming_seat); |
| ev_dev = libevdev_new(); |
| // Make the standard expectations for a successful gamepad_added_with_info |
| // request. Note that the name, bus, vendor_id, product_id and |
| // version args are referring to the host controller. At this stage, we hard |
| // code what the emulated controller will appear in the VM as, which is why |
| // the expectations below differ from the args from the host. |
| EXPECT_CALL(libevdevshim, new_evdev()).WillOnce(Return(ev_dev)); |
| EXPECT_CALL(libevdevshim, set_name(ev_dev, kXboxName)); |
| EXPECT_CALL(libevdevshim, set_id_bustype(ev_dev, kUsbBus)); |
| EXPECT_CALL(libevdevshim, set_id_vendor(ev_dev, kXboxVendor)); |
| EXPECT_CALL(libevdevshim, set_id_product(ev_dev, kXboxProduct)); |
| EXPECT_CALL(libevdevshim, set_id_version(ev_dev, kXboxVersion)); |
| for (unsigned int i = 0; i < ARRAY_SIZE(kButtons); i++) { |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_KEY, kButtons[i], nullptr)); |
| } |
| |
| HostEventHandler(ctx->gaming_seat) |
| ->gamepad_added_with_device_info(ctx, ctx->gaming_seat, gamepad, name, |
| bus, vendor_id, product_id, version); |
| } |
| |
| testing::StrictMock<MockLibevdevShim> libevdevshim; |
| }; |
| |
| TEST_F(GamepadTest, GamingSeatCreatedOnWLSeatBind) { |
| EXPECT_EQ(ctx.gaming_seat, nullptr); |
| |
| BindWLSeat(&ctx); |
| |
| EXPECT_NE(ctx.gaming_seat, nullptr); |
| } |
| |
| TEST_F(GamepadTest, AddedDoesNothing) { |
| BindWLSeat(&ctx); |
| struct zcr_gamepad_v2* gamepad = CreateGamepadProxy(ctx.gaming_seat); |
| |
| HostEventHandler(ctx.gaming_seat) |
| ->gamepad_added(&ctx, ctx.gaming_seat, gamepad); |
| |
| EXPECT_EQ(GetHostGamepads(&ctx).size(), 0); |
| } |
| |
| TEST_F(GamepadTest, AddedWithInfoSetsErrorStateOnLibevdevFail) { |
| BindWLSeat(&ctx); |
| struct zcr_gamepad_v2* gamepad = CreateGamepadProxy(ctx.gaming_seat); |
| |
| EXPECT_CALL(libevdevshim, new_evdev()).WillOnce(Return(nullptr)); |
| |
| HostEventHandler(ctx.gaming_seat) |
| ->gamepad_added_with_device_info(&ctx, ctx.gaming_seat, gamepad, "Xbox", |
| 1, 2, 3, 4); |
| |
| EXPECT_EQ(GetHostGamepads(&ctx)[0]->state, kStateError); |
| } |
| |
| TEST_F(GamepadTest, AddedWithInfoSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| EXPECT_EQ(host_gamepads[0]->state, kStatePending); |
| EXPECT_EQ(host_gamepads[0]->ev_dev, ev_dev); |
| } |
| |
| TEST_F(GamepadTest, MultipleGamepadAddedWithInfoSuccess) { |
| struct zcr_gamepad_v2* gamepad1; |
| struct libevdev* ev_dev1; |
| struct zcr_gamepad_v2* gamepad2; |
| struct libevdev* ev_dev2; |
| SetupGamepad(&ctx, gamepad1, ev_dev1, "Xbox", 1, 2, 3, 4); |
| SetupGamepad(&ctx, gamepad2, ev_dev2, "Xbox", 1, 2, 3, 4); |
| |
| EXPECT_EQ(GetHostGamepads(&ctx).size(), 2); |
| } |
| |
| TEST_F(GamepadTest, ActivatedSetsErrorStateIfGamepadNotActive) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateUnknown; |
| |
| HostEventHandler(gamepad)->activated(host_gamepads[0], gamepad); |
| |
| EXPECT_EQ(host_gamepads[0]->state, kStateError); |
| } |
| |
| TEST_F(GamepadTest, ActivatedSetsErrorStateIfLibevdevFails) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_create_from_device(ev_dev, LIBEVDEV_UINPUT_OPEN_MANAGED, |
| &host_gamepads[0]->uinput_dev)) |
| .WillOnce(Return(1)); |
| |
| HostEventHandler(gamepad)->activated(host_gamepads[0], gamepad); |
| |
| EXPECT_EQ(host_gamepads[0]->state, kStateError); |
| } |
| |
| TEST_F(GamepadTest, ActivatedSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_create_from_device(ev_dev, LIBEVDEV_UINPUT_OPEN_MANAGED, |
| &host_gamepads[0]->uinput_dev)) |
| .WillOnce(Return(0)); |
| |
| HostEventHandler(gamepad)->activated(host_gamepads[0], gamepad); |
| |
| EXPECT_EQ(host_gamepads[0]->state, kStateActivated); |
| } |
| |
| TEST_F(GamepadTest, VibratorAddedDoesNothing) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| |
| HostEventHandler(gamepad)->vibrator_added(GetHostGamepads(&ctx)[0], gamepad, |
| nullptr); |
| } |
| |
| TEST_F(GamepadTest, AxisAddedSetsErrorStateIfGamepadNotActive) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateUnknown; |
| |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, 1, 2, 3, 4, |
| 5, 6); |
| |
| EXPECT_EQ(host_gamepads[0]->state, kStateError); |
| } |
| |
| TEST_F(GamepadTest, AxisAddedSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| |
| EXPECT_CALL(libevdevshim, enable_event_code(ev_dev, EV_ABS, 1, ::testing::_)); |
| |
| HostEventHandler(gamepad)->axis_added(GetHostGamepads(&ctx)[0], gamepad, 1, 2, |
| 3, 4, 5, 6); |
| } |
| |
| TEST_F(GamepadTest, FrameDoesNothingIfGamepadNotActive) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateUnknown; |
| |
| HostEventHandler(gamepad)->frame(host_gamepads[0], gamepad, 1); |
| } |
| |
| TEST_F(GamepadTest, FrameSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateActivated; |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_SYN, SYN_REPORT, 0)); |
| |
| HostEventHandler(gamepad)->frame(host_gamepads[0], gamepad, 1); |
| } |
| |
| TEST_F(GamepadTest, ButtonDoesNothingIfGamepadNotActive) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateUnknown; |
| |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, 2, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_RELEASED, 0); |
| } |
| |
| TEST_F(GamepadTest, ButtonSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateActivated; |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_KEY, 2, 0)); |
| |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, 2, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_RELEASED, 0); |
| } |
| |
| TEST_F(GamepadTest, AxisDoesNothingIfGamepadNotActive) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateUnknown; |
| |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, 2, 250); |
| } |
| |
| TEST_F(GamepadTest, AxisSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateActivated; |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, 2, |
| wl_fixed_to_double(250))); |
| |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, 2, 250); |
| } |
| |
| TEST_F(GamepadTest, RemovedSuccess) { |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", 1, 2, 3, 4); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| host_gamepads[0]->state = kStateActivated; |
| |
| EXPECT_CALL(libevdevshim, free(host_gamepads[0]->ev_dev)); |
| |
| HostEventHandler(gamepad)->removed(host_gamepads[0], gamepad); |
| |
| EXPECT_EQ(GetHostGamepads(&ctx).size(), 0); |
| } |
| |
| TEST_F(GamepadTest, MappingsWorkCorrectly) { |
| // This object forces all EXPECT_CALLs to occur in the order they are |
| // declared. This insures expectations are paired to the correct |
| // mappings and events. |
| testing::InSequence sequence; |
| |
| BindWLSeat(&ctx); |
| for (auto& it : kDeviceMappings) { |
| // The DualShock3 (PS3) gamepad has special-case handling and we |
| // cover this in a separate test. |
| if (it.second == &kDualShock3Mapping) { |
| continue; |
| } |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", |
| ZCR_GAMING_SEAT_V2_BUS_TYPE_BLUETOOTH, it.first.vendor, |
| it.first.product, it.first.version); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| |
| EXPECT_EQ(host_gamepads.size(), 1); |
| |
| for (auto& input : it.second->mapping) { |
| EXPECT_CALL(libevdevshim, enable_event_code(ev_dev, EV_ABS, input.second, |
| ::testing::_)); |
| |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, |
| input.first, 2, 3, 4, 5, 6); |
| } |
| |
| host_gamepads[0]->state = kStateActivated; |
| |
| for (auto& input : it.second->mapping) { |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, |
| input.second, wl_fixed_to_double(250))); |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, input.second, 0)); |
| |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, input.first, |
| 250); |
| HostEventHandler(gamepad)->button( |
| host_gamepads[0], gamepad, 1, input.first, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_RELEASED, 0); |
| } |
| |
| EXPECT_EQ(host_gamepads[0]->input_mapping, it.second); |
| EXPECT_CALL(libevdevshim, free(host_gamepads[0]->ev_dev)); |
| |
| HostEventHandler(gamepad)->removed(host_gamepads[0], gamepad); |
| } |
| } |
| |
| // The DualShock3 gamepad is handled differently because it involves mapping |
| // it's DPAD buttons to axes it doesn't have. We enable those axes |
| // manually and special case it's DPAD buttons to output axis events, rather |
| // than button events. |
| TEST_F(GamepadTest, DualShock3MappingWorksCorrectly) { |
| BindWLSeat(&ctx); |
| struct zcr_gamepad_v2* gamepad; |
| struct libevdev* ev_dev; |
| |
| // The DualShock3 gamepad doesn't have these axes so we manually enable them |
| // in Sommelier. |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(::testing::_, EV_ABS, ABS_HAT0Y, ::testing::_)); |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(::testing::_, EV_ABS, ABS_HAT0X, ::testing::_)); |
| |
| SetupGamepad(&ctx, gamepad, ev_dev, "Xbox", |
| ZCR_GAMING_SEAT_V2_BUS_TYPE_BLUETOOTH, kDualShock3USB.vendor, |
| kDualShock3USB.product, kDualShock3USB.version); |
| std::vector<struct sl_host_gamepad*> host_gamepads = GetHostGamepads(&ctx); |
| |
| EXPECT_EQ(host_gamepads.size(), 1); |
| EXPECT_EQ(host_gamepads[0]->input_mapping, &kDualShock3Mapping); |
| |
| // This object forces all EXPECT_CALLs to occur in the order they are |
| // declared. This insures expectations are paired to the correct |
| // mappings and events. |
| testing::InSequence sequence; |
| |
| // Add axes. |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_ABS, ABS_X, ::testing::_)); |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, ABS_X, 2, 3, |
| 4, 5, 6); |
| |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_ABS, ABS_Y, ::testing::_)); |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, ABS_Y, 2, 3, |
| 4, 5, 6); |
| |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_ABS, ABS_RX, ::testing::_)); |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, ABS_RX, 2, 3, |
| 4, 5, 6); |
| |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_ABS, ABS_RY, ::testing::_)); |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, ABS_RY, 2, 3, |
| 4, 5, 6); |
| |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_ABS, ABS_Z, ::testing::_)); |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, ABS_Z, 2, 3, |
| 4, 5, 6); |
| |
| EXPECT_CALL(libevdevshim, |
| enable_event_code(ev_dev, EV_ABS, ABS_RZ, ::testing::_)); |
| HostEventHandler(gamepad)->axis_added(host_gamepads[0], gamepad, ABS_RZ, 2, 3, |
| 4, 5, 6); |
| |
| host_gamepads[0]->state = kStateActivated; |
| |
| // Handle axis events. |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, ABS_X, |
| wl_fixed_to_double(250))); |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, ABS_X, 250); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, ABS_Y, |
| wl_fixed_to_double(250))); |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, ABS_Y, 250); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, ABS_RX, |
| wl_fixed_to_double(250))); |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, ABS_RX, 250); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, ABS_RY, |
| wl_fixed_to_double(250))); |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, ABS_RY, 250); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, ABS_Z, |
| wl_fixed_to_double(250))); |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, ABS_Z, 250); |
| |
| EXPECT_CALL(libevdevshim, |
| uinput_write_event(host_gamepads[0]->uinput_dev, EV_ABS, ABS_RZ, |
| wl_fixed_to_double(250))); |
| HostEventHandler(gamepad)->axis(host_gamepads[0], gamepad, 1, ABS_RZ, 250); |
| |
| // Handle buttons |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_THUMBL, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_THUMBL, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_THUMBR, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_THUMBR, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_A, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_A, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_B, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_B, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_X, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_Y, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_Y, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_X, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_TL, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_TL, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_TR, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_TR, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_SELECT, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_SELECT, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_START, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_START, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_KEY, BTN_MODE, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_MODE, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| // These buttons involve converting a button event into an axis event. |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_ABS, ABS_HAT0X, -1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_DPAD_LEFT, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_ABS, ABS_HAT0X, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, |
| BTN_DPAD_RIGHT, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_ABS, ABS_HAT0Y, -1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_DPAD_UP, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| EXPECT_CALL(libevdevshim, uinput_write_event(host_gamepads[0]->uinput_dev, |
| EV_ABS, ABS_HAT0Y, 1)); |
| HostEventHandler(gamepad)->button(host_gamepads[0], gamepad, 1, BTN_DPAD_DOWN, |
| ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED, 0); |
| |
| EXPECT_CALL(libevdevshim, free(host_gamepads[0]->ev_dev)); |
| |
| HostEventHandler(gamepad)->removed(host_gamepads[0], gamepad); |
| } |
| |
| } // namespace sommelier |
| } // namespace vm_tools |
