admin/libvirtualhid
1
0 Fork 0
mirror of https://github.com/LizardByte/libvirtualhid.git synced 2026-10-24 20:17:13 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
libvirtualhid/tests/unit/test_linux_backend.cpp
T

1632 lines
78 KiB
C++
Raw Permalink Blame History

/**
* @file tests/unit/test_linux_backend.cpp
* @brief Unit tests for Linux backend internals.
*/
// standard includes
#include <algorithm>
#include <array>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <memory>
#include <optional>
#include <string>
#include <vector>
// platform includes
#include <fcntl.h>
#include <linux/input.h>
#if defined(LIBVIRTUALHID_HAVE_XTEST)
#include <X11/keysym.h>
#endif
// lib includes
#include <libevdev/libevdev.h>
#include <libvirtualhid/libvirtualhid.hpp>
// local includes
#include "fixtures/fixtures.hpp"
#include "fixtures/linux_backend_test_hooks.hpp"
/**
* @brief Test fixture for Linux backend internals.
*/
class LinuxBackendTest: public LinuxTest {};
namespace {
std::vector<std::uint16_t> pressed_key_codes(
const std::vector<lvh::detail::test::LinuxInputEventRecord> &events
) {
std::vector<std::uint16_t> pressed_codes;
for (const auto &event : events) {
if (event.type == EV_KEY && event.value == 1) {
pressed_codes.push_back(event.code);
}
}
return pressed_codes;
}
std::vector<std::int32_t> relative_axis_values(
const std::vector<lvh::detail::test::LinuxInputEventRecord> &events,
std::uint16_t code
) {
std::vector<std::int32_t> values;
for (const auto &event : events) {
if (event.type == EV_REL && event.code == code) {
values.push_back(event.value);
}
}
return values;
}
} // namespace
TEST_F(LinuxBackendTest, TranslatesKeyboardKeys) {
EXPECT_EQ(lvh::detail::test::linux_key_code(0x08), KEY_BACKSPACE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x09), KEY_TAB);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x0D), KEY_ENTER);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x10), KEY_LEFTSHIFT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x11), KEY_LEFTCTRL);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x12), KEY_LEFTALT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x14), KEY_CAPSLOCK);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x1B), KEY_ESC);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x20), KEY_SPACE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x21), KEY_PAGEUP);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x22), KEY_PAGEDOWN);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x23), KEY_END);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x24), KEY_HOME);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x25), KEY_LEFT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x26), KEY_UP);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x27), KEY_RIGHT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x28), KEY_DOWN);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x2C), KEY_SYSRQ);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x2D), KEY_INSERT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x2E), KEY_DELETE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x5B), KEY_LEFTMETA);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x5C), KEY_RIGHTMETA);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x5D), KEY_COMPOSE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x90), KEY_NUMLOCK);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x91), KEY_SCROLLLOCK);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xA0), KEY_LEFTSHIFT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xA1), KEY_RIGHTSHIFT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xA2), KEY_LEFTCTRL);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xA3), KEY_RIGHTCTRL);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xA4), KEY_LEFTALT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xA5), KEY_RIGHTALT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xBA), KEY_SEMICOLON);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xBB), KEY_EQUAL);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xBC), KEY_COMMA);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xBD), KEY_MINUS);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xBE), KEY_DOT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xBF), KEY_SLASH);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xC0), KEY_GRAVE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xDB), KEY_LEFTBRACE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xDC), KEY_BACKSLASH);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xDD), KEY_RIGHTBRACE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xDE), KEY_APOSTROPHE);
EXPECT_EQ(lvh::detail::test::linux_key_code(0xE2), KEY_102ND);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x30), KEY_0);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x31), KEY_1);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x39), KEY_9);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x41), KEY_A);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x42), KEY_B);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x5A), KEY_Z);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x60), KEY_KP0);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x61), KEY_KP1);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x69), KEY_KP9);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x6A), KEY_KPASTERISK);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x6B), KEY_KPPLUS);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x6D), KEY_KPMINUS);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x6E), KEY_KPDOT);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x6F), KEY_KPSLASH);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x70), KEY_F1);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x7B), KEY_F12);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x87), KEY_F24);
EXPECT_EQ(lvh::detail::test::linux_key_code(0), -1);
EXPECT_EQ(lvh::detail::test::linux_key_code(0x88), -1);
}
TEST_F(LinuxBackendTest, TranslatesMouseButtonsAndBusTypes) {
EXPECT_EQ(lvh::detail::test::linux_mouse_button(lvh::MouseButton::left), BTN_LEFT);
EXPECT_EQ(lvh::detail::test::linux_mouse_button(lvh::MouseButton::middle), BTN_MIDDLE);
EXPECT_EQ(lvh::detail::test::linux_mouse_button(lvh::MouseButton::right), BTN_RIGHT);
EXPECT_EQ(lvh::detail::test::linux_mouse_button(lvh::MouseButton::side), BTN_SIDE);
EXPECT_EQ(lvh::detail::test::linux_mouse_button(lvh::MouseButton::extra), BTN_EXTRA);
EXPECT_EQ(lvh::detail::test::linux_mouse_button(static_cast<lvh::MouseButton>(255)), BTN_LEFT);
EXPECT_EQ(lvh::detail::test::linux_uhid_bus(lvh::BusType::unknown), BUS_USB);
EXPECT_EQ(lvh::detail::test::linux_uhid_bus(lvh::BusType::usb), BUS_USB);
EXPECT_EQ(lvh::detail::test::linux_uhid_bus(lvh::BusType::bluetooth), BUS_BLUETOOTH);
EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::xbox_one), BUS_BLUETOOTH);
EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::xbox_series), BUS_BLUETOOTH);
EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::switch_pro), BUS_BLUETOOTH);
EXPECT_EQ(lvh::detail::test::linux_uinput_bus(lvh::BusType::bluetooth), BUS_BLUETOOTH);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::pen), BTN_TOOL_PEN);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::eraser), BTN_TOOL_RUBBER);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::brush), BTN_TOOL_BRUSH);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::pencil), BTN_TOOL_PENCIL);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::airbrush), BTN_TOOL_AIRBRUSH);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::touch), BTN_TOUCH);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::unchanged), -1);
EXPECT_EQ(lvh::detail::test::linux_pen_tool(static_cast<lvh::PenToolType>(255)), -1);
EXPECT_EQ(lvh::detail::test::linux_pen_button(lvh::PenButton::primary), BTN_STYLUS);
EXPECT_EQ(lvh::detail::test::linux_pen_button(lvh::PenButton::secondary), BTN_STYLUS2);
EXPECT_EQ(lvh::detail::test::linux_pen_button(static_cast<lvh::PenButton>(255)), BTN_STYLUS);
}
TEST_F(LinuxBackendTest, ScalesAbsoluteAxesAndScrollSteps) {
EXPECT_EQ(lvh::detail::test::linux_absolute_axis(-1, 100), 0);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis(0, 100), 0);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis(50, 100), 32767);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis(100, 100), 65535);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis(101, 100), 65535);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis(1, 0), 0);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis_to_viewport(0.0F, 1920, 0, 1920, -1920, 3840), 32768);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis_to_viewport(960.0F, 1920, 0, 1920, -1920, 3840), 49143);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis_to_viewport(1920.0F, 1920, 0, 1920, -1920, 3840), 65518);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis_to_viewport(1.0F, 0, 0, 1920, -1920, 3840), 0);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis_to_viewport(1.0F, 1, 0, 0, 0, 1), 0);
EXPECT_EQ(lvh::detail::test::linux_absolute_axis_to_viewport(1.0F, 1, 0, 1, 0, 0), 0);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(0), 0);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(1), 1);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(-1), -1);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(119), 1);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(120), 1);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(240), 2);
EXPECT_EQ(lvh::detail::test::linux_legacy_scroll_steps(-240), -2);
}
TEST_F(LinuxBackendTest, DecodesTextHelpers) {
EXPECT_EQ(
lvh::detail::test::linux_decode_utf8("A\xC3\xA9\xE2\x82\xAC\xF0\x9F\x98\x80"),
(std::vector<std::uint32_t> {0x41, 0xE9, 0x20AC, 0x1F600})
);
EXPECT_EQ(
lvh::detail::test::linux_decode_utf8(std::string {"A\xFF"
"B"}),
(std::vector<std::uint32_t> {0x41, 0x42})
);
EXPECT_EQ(
lvh::detail::test::linux_decode_utf8(std::string {"A\xC3"
"B"}),
(std::vector<std::uint32_t> {0x41, 0x42})
);
EXPECT_TRUE(lvh::detail::test::linux_decode_utf8("\xF0\x9F").empty());
EXPECT_EQ(lvh::detail::test::linux_uppercase_hex(0x1F600), "1F600");
EXPECT_EQ(lvh::detail::test::linux_hex_digit_key_code('0'), 0x30);
EXPECT_EQ(lvh::detail::test::linux_hex_digit_key_code('9'), 0x39);
EXPECT_EQ(lvh::detail::test::linux_hex_digit_key_code('A'), 0x41);
EXPECT_EQ(lvh::detail::test::linux_hex_digit_key_code('F'), 0x46);
}
TEST_F(LinuxBackendTest, CoversLinuxDiscoveryAndIdentityHelpers) {
EXPECT_EQ(lvh::detail::test::linux_dualsense_mac_address("02:03:04:05:06:07", 0x1020304), "02:03:04:05:06:07");
EXPECT_EQ(lvh::detail::test::linux_dualsense_mac_address("02-03-04-05-06-07", 0x1020304), "02:00:01:02:03:04");
EXPECT_EQ(lvh::detail::test::linux_dualsense_mac_address("ff:00:100:00:00:00", 0x1020304), "02:00:01:02:03:04");
const auto temp_dir = std::filesystem::current_path() / "cmake-build-linux-backend-test-scratch";
std::filesystem::remove_all(temp_dir);
std::filesystem::create_directories(temp_dir);
const auto first_line_path = temp_dir / "libvirtualhid-linux-first-line-test.txt";
const auto uevent_path = temp_dir / "libvirtualhid-linux-hidraw-uevent-test.txt";
{
std::ofstream file {first_line_path};
file << "libvirtualhid first line\nsecond line\n";
}
EXPECT_TRUE(lvh::detail::test::linux_first_line_matches(first_line_path.string(), "libvirtualhid first line"));
EXPECT_FALSE(lvh::detail::test::linux_first_line_matches(first_line_path.string(), "other"));
EXPECT_TRUE(lvh::detail::test::linux_first_line_missing((temp_dir / "libvirtualhid-missing-first-line-test.txt").string()));
{
std::ofstream file {uevent_path};
file << "HID_ID=0003:0000:0000\nHID_NAME=libvirtualhid hidraw\n";
}
EXPECT_TRUE(lvh::detail::test::linux_hidraw_name_matches(uevent_path.string(), "libvirtualhid hidraw"));
EXPECT_FALSE(lvh::detail::test::linux_hidraw_name_matches(uevent_path.string(), "other"));
EXPECT_FALSE(lvh::detail::test::linux_hidraw_name_matches((temp_dir / "libvirtualhid-missing-uevent-test.txt").string(), "other"));
EXPECT_TRUE(lvh::detail::test::linux_discover_nodes_by_name("").empty());
static_cast<void>(lvh::detail::test::linux_discover_nodes_by_name("libvirtualhid missing device"));
EXPECT_EQ(lvh::detail::test::linux_empty_device_nodes_count(), 0U);
const auto sysfs_root = temp_dir / "libvirtualhid-linux-sysfs-test";
const auto input_root = sysfs_root / "input";
const auto hidraw_root = sysfs_root / "hidraw";
std::filesystem::remove_all(sysfs_root);
std::filesystem::create_directories(input_root / "event0" / "device");
std::filesystem::create_directories(input_root / "js0" / "device");
std::filesystem::create_directories(input_root / "mouse0" / "device");
std::filesystem::create_directories(input_root / "event1" / "device");
std::filesystem::create_directories(hidraw_root / "hidraw0" / "device");
std::filesystem::create_directories(hidraw_root / "hidraw1" / "device");
std::filesystem::create_directories(hidraw_root / "hidraw2" / "device");
std::filesystem::create_directories(hidraw_root / "hidraw3" / "device");
std::filesystem::create_directories(hidraw_root / "hidraw4" / "device");
std::filesystem::create_directories(hidraw_root / "hidraw5" / "device");
{
std::ofstream file {input_root / "event0" / "device" / "name"};
file << "libvirtualhid device\n";
}
{
std::ofstream file {input_root / "js0" / "device" / "name"};
file << "libvirtualhid device\n";
}
{
std::ofstream file {input_root / "mouse0" / "device" / "name"};
file << "libvirtualhid device\n";
}
{
std::ofstream file {input_root / "event1" / "device" / "name"};
file << "other device\n";
}
{
std::ofstream file {hidraw_root / "hidraw0" / "device" / "uevent"};
file << "HID_NAME=libvirtualhid device\n";
}
{
std::ofstream file {hidraw_root / "hidraw1" / "device" / "uevent"};
file << "HID_NAME=other device\n";
}
{
std::ofstream file {hidraw_root / "hidraw2" / "device" / "uevent"};
file << "HID_ID=0003:0000:0000\n";
}
{
std::ofstream file {hidraw_root / "hidraw3" / "device" / "uevent"};
file << "HID_NAME=kernel renamed controller\n"
<< "HID_PHYS=libvirtualhid/uhid/42\n"
<< "HID_UNIQ=02:00:00:00:00:01\n";
}
{
std::ofstream file {hidraw_root / "hidraw4" / "device" / "uevent"};
file << "HID_NAME=other device\n"
<< "HID_PHYS=other/physical/path\n"
<< "HID_UNIQ=02:00:00:00:00:02\n";
}
{
std::ofstream file {hidraw_root / "hidraw5" / "device" / "uevent"};
file << "HID_NAME=missing hidraw name\n"
<< "HID_PHYS=other/physical/path\n"
<< "HID_UNIQ=02:00:00:00:00:02\n";
}
const auto nodes = lvh::detail::test::linux_discover_nodes_by_name(
"libvirtualhid device",
input_root.string(),
hidraw_root.string()
);
EXPECT_TRUE(std::ranges::any_of(nodes, [](const auto &node) {
return node.kind == lvh::DeviceNodeKind::input_event && node.path == "/dev/input/event0";
}));
EXPECT_TRUE(std::ranges::any_of(nodes, [](const auto &node) {
return node.kind == lvh::DeviceNodeKind::joystick && node.path == "/dev/input/js0";
}));
EXPECT_TRUE(std::ranges::any_of(nodes, [](const auto &node) {
return node.kind == lvh::DeviceNodeKind::hidraw && node.path == "/dev/hidraw0";
}));
EXPECT_TRUE(std::ranges::any_of(nodes, [sysfs_root](const auto &node) {
return node.kind == lvh::DeviceNodeKind::sysfs && node.path.starts_with(sysfs_root.string());
}));
const auto metadata_nodes = lvh::detail::test::linux_discover_hidraw_nodes_by_metadata(
"missing hidraw name",
"libvirtualhid/uhid/42",
"02:00:00:00:00:01",
hidraw_root.string()
);
EXPECT_TRUE(std::ranges::any_of(metadata_nodes, [](const auto &node) {
return node.kind == lvh::DeviceNodeKind::hidraw && node.path == "/dev/hidraw3";
}));
EXPECT_TRUE(std::ranges::any_of(metadata_nodes, [hidraw_root](const auto &node) {
return node.kind == lvh::DeviceNodeKind::sysfs && node.path == (hidraw_root / "hidraw3").string();
}));
EXPECT_FALSE(std::ranges::any_of(metadata_nodes, [](const auto &node) {
return node.path.ends_with("hidraw4") || node.path.ends_with("hidraw5");
}));
std::filesystem::remove_all(temp_dir);
}
TEST_F(LinuxBackendTest, HandlesUhidInvalidFileDescriptorPaths) {
EXPECT_EQ(
lvh::detail::test::linux_uhid_create_with_descriptor_size(
lvh::detail::test::linux_uhid_descriptor_limit() + 1
)
.code(),
lvh::ErrorCode::unsupported_profile
);
EXPECT_EQ(lvh::detail::test::linux_uhid_create_with_descriptor_size(1).code(), lvh::ErrorCode::device_closed);
EXPECT_EQ(lvh::detail::test::linux_uhid_submit_report_size(1).code(), lvh::ErrorCode::device_closed);
EXPECT_EQ(
lvh::detail::test::linux_uhid_submit_report_size(lvh::detail::test::linux_uhid_input_limit() + 1).code(),
lvh::ErrorCode::invalid_argument
);
EXPECT_EQ(lvh::detail::test::linux_uhid_submit_after_close().code(), lvh::ErrorCode::device_closed);
}
TEST_F(LinuxBackendTest, HandlesUinputKeyboardInvalidFileDescriptorPaths) {
EXPECT_EQ(lvh::detail::test::linux_uinput_keyboard_create_invalid_fd().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(
lvh::detail::test::linux_uinput_keyboard_submit_invalid_fd({.key_code = 0, .pressed = true}).code(),
lvh::ErrorCode::invalid_argument
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_keyboard_submit_invalid_fd({.key_code = 0x41, .pressed = true}).code(),
lvh::ErrorCode::device_closed
);
EXPECT_TRUE(lvh::detail::test::linux_uinput_keyboard_type_text_invalid_fd("").ok());
EXPECT_EQ(
lvh::detail::test::linux_uinput_keyboard_type_text_invalid_fd("A").code(),
lvh::ErrorCode::device_closed
);
EXPECT_EQ(lvh::detail::test::linux_uinput_keyboard_submit_after_close().code(), lvh::ErrorCode::device_closed);
}
TEST_F(LinuxBackendTest, PipeBackedUinputKeyboardEmitsEvents) {
EXPECT_EQ(lvh::detail::test::linux_copy_string_char_buffer("abcdef"), "abcd");
const auto result = lvh::detail::test::linux_uinput_keyboard_submit_pipe({.key_code = 0x41, .pressed = true});
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 2U);
EXPECT_EQ(result.events[0].type, EV_KEY);
EXPECT_EQ(result.events[0].code, KEY_A);
EXPECT_EQ(result.events[0].value, 1);
EXPECT_EQ(result.events[1].type, EV_SYN);
EXPECT_EQ(result.events[1].code, SYN_REPORT);
EXPECT_EQ(result.events[1].value, 0);
EXPECT_EQ(lvh::detail::test::linux_uinput_user_device_invalid_fd().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(lvh::detail::test::linux_uinput_user_device_pipe().code(), lvh::ErrorCode::backend_failure);
}
TEST_F(LinuxBackendTest, PipeBackedUinputKeyboardEmitsComposeKey) {
for (const auto pressed : {true, false}) {
const auto result = lvh::detail::test::linux_uinput_keyboard_submit_pipe({.key_code = 0x5D, .pressed = pressed});
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 2U);
EXPECT_EQ(result.events[0].type, EV_KEY);
EXPECT_EQ(result.events[0].code, KEY_COMPOSE);
EXPECT_EQ(result.events[0].value, pressed ? 1 : 0);
EXPECT_EQ(result.events[1].type, EV_SYN);
EXPECT_EQ(result.events[1].code, SYN_REPORT);
}
}
TEST_F(LinuxBackendTest, UinputKeyboardEmitsOnlySubmittedKeyTransitions) {
const auto default_interval = lvh::CreateKeyboardOptions {}.auto_repeat_interval_ms;
for (const auto interval_ms : {0U, 1U, default_interval}) {
SCOPED_TRACE(interval_ms);
const auto result = lvh::detail::test::linux_uinput_keyboard_held_key_events(interval_ms);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 4U);
for (std::size_t index = 0; index < 2; ++index) {
const auto &key = result.events[index * 2];
EXPECT_EQ(key.type, EV_KEY);
EXPECT_EQ(key.code, KEY_F);
EXPECT_EQ(key.value, index == 0 ? 1 : 0);
const auto &sync = result.events[index * 2 + 1];
EXPECT_EQ(sync.type, EV_SYN);
EXPECT_EQ(sync.code, SYN_REPORT);
EXPECT_EQ(sync.value, 0);
}
}
}
TEST_F(LinuxBackendTest, PipeBackedUinputGamepadsUseCanonicalLinuxEvents) {
using enum lvh::GamepadButton;
using enum lvh::GamepadProfileKind;
struct ButtonCase {
lvh::GamepadButton button;
std::uint16_t linux_code;
};
constexpr std::array button_cases {
ButtonCase {a, BTN_SOUTH},
ButtonCase {b, BTN_EAST},
ButtonCase {x, BTN_NORTH},
ButtonCase {y, BTN_WEST},
ButtonCase {left_shoulder, BTN_TL},
ButtonCase {right_shoulder, BTN_TR},
ButtonCase {back, BTN_SELECT},
ButtonCase {start, BTN_START},
ButtonCase {guide, BTN_MODE},
ButtonCase {left_stick, BTN_THUMBL},
ButtonCase {right_stick, BTN_THUMBR},
};
constexpr std::array profile_kinds {generic, xbox_360, xbox_one, xbox_series};
for (const auto kind : profile_kinds) {
for (const auto &[button, linux_code] : button_cases) {
lvh::GamepadState state;
state.buttons.set(button);
const auto result = lvh::detail::test::linux_uinput_gamepad_submit_pipe(kind, state);
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto pressed_codes = pressed_key_codes(result.events);
ASSERT_EQ(pressed_codes.size(), 1U)
<< "profile " << static_cast<int>(std::to_underlying(kind)) << " logical button "
<< static_cast<int>(std::to_underlying(button));
EXPECT_EQ(pressed_codes.front(), linux_code)
<< "profile " << static_cast<int>(std::to_underlying(kind)) << " logical button "
<< static_cast<int>(std::to_underlying(button));
}
}
for (const auto kind : {generic, xbox_series}) {
lvh::GamepadState state;
state.buttons.set(misc1);
const auto result = lvh::detail::test::linux_uinput_gamepad_submit_pipe(kind, state);
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto pressed = std::ranges::find_if(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == KEY_RECORD && event.value == 1;
});
EXPECT_NE(pressed, result.events.end());
}
for (const auto kind : profile_kinds) {
lvh::GamepadState state;
state.buttons.set(dpad_up);
state.buttons.set(dpad_right);
state.left_stick = {.x = -0.5F, .y = 0.25F};
state.right_stick = {.x = 0.75F, .y = -1.0F};
state.left_trigger = 0.25F;
state.right_trigger = 0.75F;
const auto result = lvh::detail::test::linux_uinput_gamepad_submit_pipe(kind, state);
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto event_value = [&result](std::uint16_t type, std::uint16_t code) -> std::optional<std::int32_t> {
const auto event = std::ranges::find_if(result.events, [type, code](const auto &candidate) {
return candidate.type == type && candidate.code == code;
});
if (event == result.events.end()) {
return std::nullopt;
}
return event->value;
};
EXPECT_EQ(event_value(EV_ABS, ABS_HAT0X), 1);
EXPECT_EQ(event_value(EV_ABS, ABS_HAT0Y), -1);
for (const auto dpad_button : {BTN_DPAD_UP, BTN_DPAD_DOWN, BTN_DPAD_LEFT, BTN_DPAD_RIGHT}) {
EXPECT_EQ(event_value(EV_KEY, dpad_button), std::nullopt);
}
EXPECT_EQ(event_value(EV_ABS, ABS_X), lvh::reports::normalize_axis(-0.5F));
EXPECT_EQ(event_value(EV_ABS, ABS_Y), lvh::reports::normalize_axis(-0.25F));
EXPECT_EQ(event_value(EV_ABS, ABS_RX), lvh::reports::normalize_axis(0.75F));
EXPECT_EQ(event_value(EV_ABS, ABS_RY), lvh::reports::normalize_axis(1.0F));
EXPECT_EQ(event_value(EV_ABS, ABS_Z), lvh::reports::normalize_trigger(0.25F));
EXPECT_EQ(event_value(EV_ABS, ABS_RZ), lvh::reports::normalize_trigger(0.75F));
}
}
TEST_F(LinuxBackendTest, UinputGamepadsNormalizeForceFeedback) {
using enum lvh::GamepadProfileKind;
for (const auto kind : {
generic,
xbox_360,
xbox_one,
xbox_series,
}) {
for (const auto effect_type : {FF_RUMBLE, FF_CONSTANT, FF_PERIODIC, FF_RAMP}) {
const auto result = lvh::detail::test::linux_uinput_gamepad_fake_rumble(kind, effect_type);
ASSERT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
ASSERT_GE(result.callback_count, 1U);
EXPECT_EQ(result.last_output.kind, lvh::GamepadOutputKind::rumble);
if (effect_type == FF_RUMBLE) {
EXPECT_EQ(result.last_output.low_frequency_rumble, 0x5678);
EXPECT_EQ(result.last_output.high_frequency_rumble, 0x1234);
} else {
EXPECT_GT(result.last_output.low_frequency_rumble, 0);
EXPECT_GT(result.last_output.high_frequency_rumble, 0);
}
}
}
}
TEST_F(LinuxBackendTest, UinputGamepadKeepsInfiniteRumbleActiveUntilExplicitStop) {
const auto result = lvh::detail::test::linux_uinput_gamepad_fake_rumble(
lvh::GamepadProfileKind::xbox_series,
FF_RUMBLE,
0,
true
);
ASSERT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
ASSERT_GE(result.nonzero_callback_count, 1U);
EXPECT_GE(result.zero_callback_count_before_close, 1U);
EXPECT_EQ(result.last_output.kind, lvh::GamepadOutputKind::rumble);
EXPECT_EQ(result.last_output.low_frequency_rumble, 0x5678);
EXPECT_EQ(result.last_output.high_frequency_rumble, 0x1234);
}
TEST_F(LinuxBackendTest, UinputGamepadRecalculatesActiveRumbleEndAfterReupload) {
const auto result = lvh::detail::test::linux_uinput_gamepad_fake_rumble(
lvh::GamepadProfileKind::xbox_series,
FF_RUMBLE,
0,
false,
1
);
ASSERT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_GE(result.nonzero_callback_count, 1U);
EXPECT_GE(result.zero_callback_count_before_close, 1U);
}
TEST_F(LinuxBackendTest, UinputGamepadRestartsTimingForEachRumblePlaybackCycle) {
const auto first_cycle = lvh::detail::test::linux_uinput_rumble_cycle_timing(25, 100);
EXPECT_EQ(first_cycle.elapsed, 25U);
EXPECT_EQ(first_cycle.remaining, 75U);
const auto second_cycle = lvh::detail::test::linux_uinput_rumble_cycle_timing(125, 100);
EXPECT_EQ(second_cycle.elapsed, first_cycle.elapsed);
EXPECT_EQ(second_cycle.remaining, first_cycle.remaining);
const auto cycle_boundary = lvh::detail::test::linux_uinput_rumble_cycle_timing(200, 100);
EXPECT_EQ(cycle_boundary.elapsed, 0U);
EXPECT_EQ(cycle_boundary.remaining, 100U);
}
TEST_F(LinuxBackendTest, HandlesUinputMouseInvalidFileDescriptorPaths) {
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_create_invalid_fd().code(), lvh::ErrorCode::backend_failure);
lvh::MouseEvent event;
event.kind = static_cast<lvh::MouseEventKind>(255);
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::invalid_argument);
event.kind = lvh::MouseEventKind::relative_motion;
event.x = 5;
event.y = 0;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
event.x = 0;
event.y = 5;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
event.y = 0;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
event.kind = lvh::MouseEventKind::absolute_motion;
event.x = 50;
event.y = 75;
event.width = 100;
event.height = 100;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
event.kind = lvh::MouseEventKind::button;
event.button = lvh::MouseButton::side;
event.pressed = true;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
event.kind = lvh::MouseEventKind::vertical_scroll;
event.high_resolution_scroll = 120;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
event.kind = lvh::MouseEventKind::horizontal_scroll;
event.high_resolution_scroll = -120;
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_invalid_fd(event).code(), lvh::ErrorCode::device_closed);
EXPECT_EQ(lvh::detail::test::linux_uinput_mouse_submit_after_close().code(), lvh::ErrorCode::device_closed);
}
TEST_F(LinuxBackendTest, PipeBackedUinputMouseEmitsEvents) {
lvh::MouseEvent event;
event.kind = lvh::MouseEventKind::relative_motion;
event.x = 5;
event.y = -2;
auto result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 3U);
EXPECT_EQ(result.events[0].type, EV_REL);
EXPECT_EQ(result.events[0].code, REL_X);
EXPECT_EQ(result.events[0].value, 5);
EXPECT_EQ(result.events[1].type, EV_REL);
EXPECT_EQ(result.events[1].code, REL_Y);
EXPECT_EQ(result.events[1].value, -2);
EXPECT_EQ(result.events[2].type, EV_SYN);
event = {};
event.kind = lvh::MouseEventKind::absolute_motion;
event.x = 50;
event.y = 100;
event.width = 100;
event.height = 100;
result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 3U);
EXPECT_EQ(result.events[0].type, EV_ABS);
EXPECT_EQ(result.events[0].code, ABS_X);
EXPECT_EQ(result.events[0].value, 32767);
EXPECT_EQ(result.events[1].type, EV_ABS);
EXPECT_EQ(result.events[1].code, ABS_Y);
EXPECT_EQ(result.events[1].value, 65535);
EXPECT_EQ(result.events[2].type, EV_SYN);
event.x = 2580;
event.y = 1080;
event.width = 3440;
event.height = 1440;
result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 3U);
EXPECT_EQ(result.events[0].type, EV_ABS);
EXPECT_EQ(result.events[0].code, ABS_X);
EXPECT_EQ(result.events[0].value, 49151);
EXPECT_EQ(result.events[1].type, EV_ABS);
EXPECT_EQ(result.events[1].code, ABS_Y);
EXPECT_EQ(result.events[1].value, 49151);
EXPECT_EQ(result.events[2].type, EV_SYN);
event = {};
event.kind = lvh::MouseEventKind::button;
event.button = lvh::MouseButton::extra;
event.pressed = true;
result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 2U);
EXPECT_EQ(result.events[0].type, EV_KEY);
EXPECT_EQ(result.events[0].code, BTN_EXTRA);
EXPECT_EQ(result.events[0].value, 1);
EXPECT_EQ(result.events[1].type, EV_SYN);
event = {};
event.kind = lvh::MouseEventKind::vertical_scroll;
event.high_resolution_scroll = 120;
result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event);
ASSERT_TRUE(result.status.ok()) << result.status.message();
#if defined(REL_WHEEL_HI_RES)
constexpr auto expected_vertical_scroll_event_count = 3U;
#else
constexpr auto expected_vertical_scroll_event_count = 2U;
#endif
ASSERT_EQ(result.events.size(), expected_vertical_scroll_event_count);
EXPECT_EQ(result.events[0].type, EV_REL);
EXPECT_EQ(result.events[0].code, REL_WHEEL);
EXPECT_EQ(result.events[0].value, 1);
#if defined(REL_WHEEL_HI_RES)
EXPECT_EQ(result.events[1].type, EV_REL);
EXPECT_EQ(result.events[1].code, REL_WHEEL_HI_RES);
EXPECT_EQ(result.events[1].value, 120);
#endif
EXPECT_EQ(result.events.back().type, EV_SYN);
event = {};
event.kind = lvh::MouseEventKind::horizontal_scroll;
event.high_resolution_scroll = -120;
result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event);
ASSERT_TRUE(result.status.ok()) << result.status.message();
#if defined(REL_HWHEEL_HI_RES)
constexpr auto expected_horizontal_scroll_event_count = 3U;
#else
constexpr auto expected_horizontal_scroll_event_count = 2U;
#endif
ASSERT_EQ(result.events.size(), expected_horizontal_scroll_event_count);
EXPECT_EQ(result.events[0].type, EV_REL);
EXPECT_EQ(result.events[0].code, REL_HWHEEL);
EXPECT_EQ(result.events[0].value, -1);
#if defined(REL_HWHEEL_HI_RES)
EXPECT_EQ(result.events[1].type, EV_REL);
EXPECT_EQ(result.events[1].code, REL_HWHEEL_HI_RES);
EXPECT_EQ(result.events[1].value, -120);
#endif
EXPECT_EQ(result.events.back().type, EV_SYN);
}
TEST_F(LinuxBackendTest, PipeBackedUinputMouseMapsConfiguredViewport) {
lvh::MouseEvent event {
.kind = lvh::MouseEventKind::absolute_motion,
.x = 960,
.y = 540,
.width = 1920,
.height = 1080,
};
lvh::CreateMouseOptions options;
options.desktop = {.offset_x = -1920, .offset_y = 0, .width = 3840, .height = 1080};
options.viewport = {.offset_x = 0, .offset_y = 0, .width = 1920, .height = 1080};
const auto result = lvh::detail::test::linux_uinput_mouse_submit_pipe(event, options);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.events.size(), 3U);
EXPECT_EQ(result.events[0].code, ABS_X);
EXPECT_EQ(result.events[0].value, 49143);
EXPECT_EQ(result.events[1].code, ABS_Y);
EXPECT_EQ(result.events[1].value, 32737);
}
TEST_F(LinuxBackendTest, PipeBackedUinputMouseRoutesMotionAndButtonsAcrossSplitDevices) {
const std::vector<lvh::MouseEvent> events {
{.kind = lvh::MouseEventKind::absolute_motion, .x = 50, .y = 25, .width = 100, .height = 100},
{.kind = lvh::MouseEventKind::button, .button = lvh::MouseButton::side, .pressed = true},
{.kind = lvh::MouseEventKind::relative_motion, .x = 5, .y = -2},
{.kind = lvh::MouseEventKind::button, .button = lvh::MouseButton::side, .pressed = false},
{.kind = lvh::MouseEventKind::button, .button = lvh::MouseButton::extra, .pressed = true},
{.kind = lvh::MouseEventKind::button, .button = lvh::MouseButton::extra, .pressed = false},
};
const auto result = lvh::detail::test::linux_uinput_mouse_submit_split_pipe_sequence(events);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_EQ(result.absolute_events.size(), 7U);
EXPECT_EQ(result.absolute_events[0].type, EV_ABS);
EXPECT_EQ(result.absolute_events[0].code, ABS_X);
EXPECT_EQ(result.absolute_events[1].type, EV_ABS);
EXPECT_EQ(result.absolute_events[1].code, ABS_Y);
EXPECT_EQ(result.absolute_events[3].type, EV_KEY);
EXPECT_EQ(result.absolute_events[3].code, BTN_SIDE);
EXPECT_EQ(result.absolute_events[3].value, 1);
EXPECT_EQ(result.absolute_events[5].type, EV_KEY);
EXPECT_EQ(result.absolute_events[5].code, BTN_SIDE);
EXPECT_EQ(result.absolute_events[5].value, 0);
EXPECT_TRUE(std::ranges::none_of(result.absolute_events, [](const auto &event) {
return event.type == EV_REL;
}));
ASSERT_EQ(result.relative_events.size(), 7U);
EXPECT_EQ(result.relative_events[0].type, EV_REL);
EXPECT_EQ(result.relative_events[0].code, REL_X);
EXPECT_EQ(result.relative_events[1].type, EV_REL);
EXPECT_EQ(result.relative_events[1].code, REL_Y);
EXPECT_EQ(result.relative_events[3].type, EV_KEY);
EXPECT_EQ(result.relative_events[3].code, BTN_EXTRA);
EXPECT_EQ(result.relative_events[3].value, 1);
EXPECT_EQ(result.relative_events[5].type, EV_KEY);
EXPECT_EQ(result.relative_events[5].code, BTN_EXTRA);
EXPECT_EQ(result.relative_events[5].value, 0);
EXPECT_TRUE(std::ranges::none_of(result.relative_events, [](const auto &event) {
return event.type == EV_ABS;
}));
}
TEST_F(LinuxBackendTest, PipeBackedUinputMouseScrollsOnLastMotionDevice) {
using enum lvh::MouseEventKind;
const std::vector<lvh::MouseEvent> events {
{.kind = absolute_motion, .x = 50, .y = 25, .width = 100, .height = 100},
{.kind = vertical_scroll, .high_resolution_scroll = 120},
{.kind = horizontal_scroll, .high_resolution_scroll = -120},
{.kind = relative_motion, .x = 5, .y = -2},
{.kind = vertical_scroll, .high_resolution_scroll = -120},
};
const auto result = lvh::detail::test::linux_uinput_mouse_submit_split_pipe_sequence(events);
ASSERT_TRUE(result.status.ok()) << result.status.message();
EXPECT_EQ(relative_axis_values(result.absolute_events, REL_WHEEL), (std::vector<std::int32_t> {1}));
EXPECT_EQ(relative_axis_values(result.absolute_events, REL_HWHEEL), (std::vector<std::int32_t> {-1}));
EXPECT_EQ(relative_axis_values(result.relative_events, REL_WHEEL), (std::vector<std::int32_t> {-1}));
#if defined(REL_WHEEL_HI_RES)
EXPECT_EQ(relative_axis_values(result.absolute_events, REL_WHEEL_HI_RES), (std::vector<std::int32_t> {120}));
EXPECT_EQ(relative_axis_values(result.relative_events, REL_WHEEL_HI_RES), (std::vector<std::int32_t> {-120}));
#endif
}
TEST_F(LinuxBackendTest, PipeBackedUinputMouseAccumulatesLegacyScrollDetentsPerAxis) {
const std::vector<lvh::MouseEvent> events {
{.kind = lvh::MouseEventKind::vertical_scroll, .high_resolution_scroll = 60},
{.kind = lvh::MouseEventKind::horizontal_scroll, .high_resolution_scroll = -60},
{.kind = lvh::MouseEventKind::vertical_scroll, .high_resolution_scroll = 60},
{.kind = lvh::MouseEventKind::horizontal_scroll, .high_resolution_scroll = -60},
};
const auto result = lvh::detail::test::linux_uinput_mouse_submit_pipe_sequence(events);
ASSERT_TRUE(result.status.ok()) << result.status.message();
EXPECT_EQ(relative_axis_values(result.events, REL_WHEEL), (std::vector<std::int32_t> {1}));
EXPECT_EQ(relative_axis_values(result.events, REL_HWHEEL), (std::vector<std::int32_t> {-1}));
#if defined(REL_WHEEL_HI_RES)
EXPECT_EQ(relative_axis_values(result.events, REL_WHEEL_HI_RES), (std::vector<std::int32_t> {60, 60}));
#endif
#if defined(REL_HWHEEL_HI_RES)
EXPECT_EQ(relative_axis_values(result.events, REL_HWHEEL_HI_RES), (std::vector<std::int32_t> {-60, -60}));
#endif
EXPECT_EQ(
std::ranges::count_if(result.events, [](const auto &event) {
return event.type == EV_SYN && event.code == SYN_REPORT;
}),
4
);
}
TEST_F(LinuxBackendTest, PipeBackedUinputTouchDevicesEmitEvents) {
const lvh::TouchContact contact {
.id = 7,
.x = 0.5F,
.y = 0.25F,
.pressure = 0.75F,
.orientation = 45,
};
auto result = lvh::detail::test::linux_uinput_touchscreen_contact_pipe(contact);
ASSERT_TRUE(result.status.ok()) << result.status.message();
ASSERT_GE(result.events.size(), 10U);
EXPECT_EQ(result.events[0].type, EV_ABS);
EXPECT_EQ(result.events[0].code, ABS_MT_SLOT);
EXPECT_EQ(result.events[1].type, EV_ABS);
EXPECT_EQ(result.events[1].code, ABS_MT_TRACKING_ID);
EXPECT_EQ(result.events[2].type, EV_KEY);
EXPECT_EQ(result.events[2].code, BTN_TOUCH);
EXPECT_EQ(result.events[2].value, 1);
EXPECT_EQ(result.events[3].type, EV_ABS);
EXPECT_EQ(result.events[3].code, ABS_X);
EXPECT_EQ(result.events[4].type, EV_ABS);
EXPECT_EQ(result.events[4].code, ABS_MT_POSITION_X);
result = lvh::detail::test::linux_uinput_trackpad_contact_pipe(contact);
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto saw_left_button = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_LEFT && event.value == 1;
});
const auto saw_finger_tool = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_FINGER && event.value == 1;
});
EXPECT_TRUE(saw_left_button);
EXPECT_TRUE(saw_finger_tool);
const lvh::PenToolState tool {
.tool = lvh::PenToolType::pen,
.x = 0.25F,
.y = 0.5F,
.pressure = 0.5F,
.distance = -1.0F,
.tilt_x = 45.0F,
.tilt_y = -45.0F,
};
result = lvh::detail::test::linux_uinput_pen_tablet_tool_pipe(tool);
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto saw_pen_tool = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_PEN && event.value == 1;
});
const auto saw_pressure = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_ABS && event.code == ABS_PRESSURE && event.value > 0;
});
const auto saw_stylus = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_STYLUS && event.value == 1;
});
EXPECT_TRUE(saw_pen_tool);
EXPECT_TRUE(saw_pressure);
EXPECT_TRUE(saw_stylus);
}
TEST_F(LinuxBackendTest, PipeBackedUinputTouchDevicesCoverStateTransitions) {
auto result = lvh::detail::test::linux_uinput_trackpad_multi_contact_pipe();
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto saw_doubletap = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_DOUBLETAP && event.value == 1;
});
const auto saw_tripletap = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_TRIPLETAP && event.value == 1;
});
const auto saw_quadtap = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_QUADTAP && event.value == 1;
});
const auto saw_quinttap = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_QUINTTAP && event.value == 1;
});
EXPECT_TRUE(saw_doubletap);
EXPECT_TRUE(saw_tripletap);
EXPECT_TRUE(saw_quadtap);
EXPECT_TRUE(saw_quinttap);
EXPECT_EQ(lvh::detail::test::linux_uinput_touchscreen_invalid_contacts().code(), lvh::ErrorCode::invalid_argument);
result = lvh::detail::test::linux_uinput_pen_tablet_transition_pipe();
ASSERT_TRUE(result.status.ok()) << result.status.message();
const auto saw_rubber = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_RUBBER && event.value == 1;
});
const auto saw_pen_release = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_TOOL_PEN && event.value == 0;
});
const auto saw_distance = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_ABS && event.code == ABS_DISTANCE && event.value > 0;
});
const auto saw_secondary_button = std::ranges::any_of(result.events, [](const auto &event) {
return event.type == EV_KEY && event.code == BTN_STYLUS2 && event.value == 1;
});
EXPECT_TRUE(saw_rubber);
EXPECT_TRUE(saw_pen_release);
EXPECT_TRUE(saw_distance);
EXPECT_TRUE(saw_secondary_button);
EXPECT_EQ(lvh::detail::test::linux_uinput_pen_tablet_closed_status().code(), lvh::ErrorCode::device_closed);
}
TEST_F(LinuxBackendTest, PipeBackedUinputTouchDevicesReuseSlotsWithNewTrackingIds) {
for (const auto device_type : {lvh::DeviceType::touchscreen, lvh::DeviceType::trackpad}) {
const auto result = lvh::detail::test::linux_uinput_touch_contact_reuse_pipe(device_type);
ASSERT_TRUE(result.status.ok()) << result.status.message();
std::vector<std::int32_t> selected_slots;
std::vector<std::int32_t> tracking_ids;
for (const auto &event : result.events) {
if (event.type == EV_ABS && event.code == ABS_MT_SLOT) {
selected_slots.push_back(event.value);
} else if (event.type == EV_ABS && event.code == ABS_MT_TRACKING_ID) {
tracking_ids.push_back(event.value);
}
}
EXPECT_EQ(selected_slots, (std::vector<std::int32_t> {0, 1, 0, 1}));
EXPECT_EQ(tracking_ids, (std::vector<std::int32_t> {0, 1, -1, 2}));
}
EXPECT_EQ(
lvh::detail::test::linux_uinput_touch_contact_reuse_pipe(lvh::DeviceType::mouse).status.code(),
lvh::ErrorCode::invalid_argument
);
}
TEST_F(LinuxBackendTest, SocketpairBackedUhidGamepadRoundTripsEvents) {
const auto result = lvh::detail::test::linux_uhid_socketpair_roundtrip();
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.submit_status.ok()) << result.submit_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_EQ(result.creation.name, lvh::profiles::xbox_360().name);
EXPECT_TRUE(result.saw_input);
EXPECT_TRUE(result.saw_get_report_reply);
EXPECT_TRUE(result.saw_set_report_reply);
EXPECT_TRUE(result.saw_destroy);
EXPECT_GE(result.output.callback_count, 2U);
EXPECT_EQ(result.output.last.kind, lvh::GamepadOutputKind::rumble);
EXPECT_EQ(result.output.last.low_frequency_rumble, 0x5678);
EXPECT_EQ(result.output.last.high_frequency_rumble, 0x1234);
}
TEST_F(LinuxBackendTest, XboxOneAndSeriesPreferBluetoothUhidWithUinputFallback) {
using enum lvh::GamepadProfileKind;
EXPECT_FALSE(lvh::detail::test::linux_gamepad_prefers_uhid(generic));
EXPECT_FALSE(lvh::detail::test::linux_gamepad_prefers_uhid(xbox_360));
EXPECT_TRUE(lvh::detail::test::linux_gamepad_prefers_uhid(switch_pro));
EXPECT_TRUE(lvh::detail::test::linux_gamepad_prefers_uhid(dualshock4));
EXPECT_TRUE(lvh::detail::test::linux_gamepad_prefers_uhid(dualsense));
for (const auto kind : {xbox_one, xbox_series}) {
EXPECT_TRUE(lvh::detail::test::linux_gamepad_prefers_uhid(kind));
EXPECT_TRUE(lvh::detail::test::linux_gamepad_uses_uinput(kind));
const auto effective_profile = lvh::detail::test::linux_uinput_effective_gamepad_profile(kind);
EXPECT_TRUE(effective_profile.capabilities.supports_rumble);
EXPECT_FALSE(effective_profile.capabilities.supports_trigger_rumble);
EXPECT_FALSE(effective_profile.capabilities.supports_battery);
const auto result = lvh::detail::test::linux_xbox_bluetooth_uhid_socketpair_reports(kind, true, true);
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.submit_status.ok()) << result.submit_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_TRUE(result.xbox.saw_transport_descriptor);
// The kernel must not match Microsoft's physical-device driver IDs, while
// the 16-bit input and hidraw identities must still identify an Xbox.
EXPECT_EQ(result.creation.vendor_id, 0x0001045EU);
EXPECT_NE(result.creation.vendor_id, 0x045EU);
EXPECT_EQ(static_cast<std::uint16_t>(result.creation.vendor_id), 0x045EU);
EXPECT_EQ(result.creation.product_id, kind == xbox_series ? 0x0B13U : 0x0B20U);
EXPECT_TRUE(result.xbox.saw_battery_descriptor);
EXPECT_TRUE(result.xbox.saw_canonical_evdev_axes);
EXPECT_TRUE(result.xbox.saw_gamepad_application_usage);
EXPECT_TRUE(result.xbox.saw_bluetooth_identity);
EXPECT_TRUE(result.xbox.saw_input);
EXPECT_TRUE(result.xbox.saw_battery_input);
EXPECT_TRUE(result.xbox.saw_guide);
EXPECT_TRUE(result.xbox.saw_profile_consumer_button);
EXPECT_TRUE(result.saw_destroy);
ASSERT_TRUE(result.output.rumble.has_value());
EXPECT_EQ(result.output.rumble->low_frequency_rumble, 49151U);
EXPECT_EQ(result.output.rumble->high_frequency_rumble, 65535U);
ASSERT_TRUE(result.output.trigger_rumble.has_value());
EXPECT_EQ(result.output.trigger_rumble->left_trigger_rumble, 16384U);
EXPECT_EQ(result.output.trigger_rumble->right_trigger_rumble, 32768U);
const auto no_battery_result = lvh::detail::test::linux_xbox_bluetooth_uhid_socketpair_reports(kind, false, true);
EXPECT_TRUE(no_battery_result.create_status.ok()) << no_battery_result.create_status.message();
EXPECT_TRUE(no_battery_result.submit_status.ok()) << no_battery_result.submit_status.message();
EXPECT_TRUE(no_battery_result.close_status.ok()) << no_battery_result.close_status.message();
EXPECT_TRUE(no_battery_result.creation.saw_create);
EXPECT_TRUE(no_battery_result.xbox.saw_transport_descriptor);
EXPECT_FALSE(no_battery_result.xbox.saw_battery_descriptor);
EXPECT_TRUE(no_battery_result.xbox.saw_input);
EXPECT_FALSE(no_battery_result.xbox.saw_battery_input);
EXPECT_TRUE(no_battery_result.saw_destroy);
const auto missing_battery_result = lvh::detail::test::linux_xbox_bluetooth_uhid_socketpair_reports(kind, true, false);
EXPECT_TRUE(missing_battery_result.create_status.ok()) << missing_battery_result.create_status.message();
EXPECT_TRUE(missing_battery_result.submit_status.ok()) << missing_battery_result.submit_status.message();
EXPECT_TRUE(missing_battery_result.close_status.ok()) << missing_battery_result.close_status.message();
EXPECT_TRUE(missing_battery_result.creation.saw_create);
EXPECT_TRUE(missing_battery_result.xbox.saw_transport_descriptor);
EXPECT_TRUE(missing_battery_result.xbox.saw_battery_descriptor);
EXPECT_TRUE(missing_battery_result.xbox.saw_input);
EXPECT_FALSE(missing_battery_result.xbox.saw_battery_input);
EXPECT_TRUE(missing_battery_result.saw_destroy);
}
}
TEST_F(LinuxBackendTest, SocketpairBackedSwitchProUsesNativeUhidProtocol) {
const auto result = lvh::detail::test::linux_switch_pro_uhid_socketpair_reports();
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.submit_status.ok()) << result.submit_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_EQ(result.creation.name, lvh::profiles::switch_pro().name);
EXPECT_EQ(result.creation.vendor_id, 0x057EU);
EXPECT_EQ(result.creation.product_id, 0x2009U);
EXPECT_EQ(result.creation.physical_id, "libvirtualhid/uhid/057e:2009/12");
EXPECT_EQ(result.creation.unique_id, "057e:2009/streaming-host-gamepad-0");
EXPECT_TRUE(result.switch_pro.saw_subcommand_reply);
EXPECT_TRUE(result.switch_pro.saw_motion_input);
ASSERT_TRUE(result.switch_pro.subcommand_reply_packet_timer.has_value());
ASSERT_TRUE(result.switch_pro.motion_input_packet_timer.has_value());
EXPECT_NE(
*result.switch_pro.motion_input_packet_timer,
*result.switch_pro.subcommand_reply_packet_timer
);
EXPECT_TRUE(result.switch_pro.saw_player_leds);
ASSERT_EQ(result.output.callback_count, 2U);
EXPECT_EQ(result.output.last.kind, lvh::GamepadOutputKind::player_leds);
}
TEST_F(LinuxBackendTest, SwitchProStreamsIdleAndLatestStateUntilClosed) {
const auto result = lvh::detail::test::linux_switch_pro_uhid_socketpair_reports();
ASSERT_TRUE(result.create_status.ok()) << result.create_status.message();
ASSERT_TRUE(result.submit_status.ok()) << result.submit_status.message();
ASSERT_TRUE(result.switch_pro.clear_status.ok()) << result.switch_pro.clear_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
for (const auto &reports : {
result.switch_pro.idle_input_reports,
result.switch_pro.repeated_input_reports,
result.switch_pro.cleared_input_reports,
}) {
ASSERT_EQ(reports.size(), 2U);
EXPECT_EQ(reports[0].size(), lvh::profiles::switch_pro().input_report_size);
EXPECT_EQ(reports[0][0], 0x30U);
EXPECT_NE(reports[0][1], reports[1][1]);
EXPECT_TRUE(std::equal(reports[0].begin() + 2, reports[0].end(), reports[1].begin() + 2));
}
EXPECT_TRUE(result.saw_destroy);
EXPECT_TRUE(result.switch_pro.stopped_after_destroy);
}
TEST_F(LinuxBackendTest, SocketpairBackedDualSenseRepliesToFeatureReports) {
const auto result = lvh::detail::test::linux_dualsense_uhid_socketpair_reports();
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_EQ(result.creation.name, "Wireless Controller");
EXPECT_TRUE(result.dualsense.saw_calibration);
EXPECT_TRUE(result.dualsense.saw_pairing);
EXPECT_TRUE(result.dualsense.saw_firmware);
EXPECT_TRUE(result.saw_set_report_reply);
ASSERT_GE(result.output.callback_count, 1U);
EXPECT_EQ(result.output.last.kind, lvh::GamepadOutputKind::rumble);
EXPECT_EQ(result.output.last.low_frequency_rumble, 0x5656);
EXPECT_EQ(result.output.last.high_frequency_rumble, 0x1212);
}
TEST_F(LinuxBackendTest, SocketpairBackedDualSenseBluetoothFramesReports) {
const auto result = lvh::detail::test::linux_dualsense_bluetooth_uhid_socketpair_reports();
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.submit_status.ok()) << result.submit_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_EQ(result.creation.name, "Wireless Controller");
EXPECT_TRUE(result.dualsense.saw_bluetooth_input_with_live_sensor_metadata);
EXPECT_TRUE(result.dualsense.saw_pairing);
EXPECT_TRUE(result.dualsense.saw_feature_crc);
}
TEST_F(LinuxBackendTest, SocketpairBackedDualShock4RepliesToFeatureReports) {
const auto result = lvh::detail::test::linux_dualshock4_uhid_socketpair_reports();
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_EQ(result.creation.name, "Wireless Controller");
EXPECT_TRUE(result.dualshock4.saw_usb_input);
EXPECT_TRUE(result.dualshock4.saw_calibration);
EXPECT_TRUE(result.dualshock4.saw_pairing);
EXPECT_TRUE(result.dualshock4.saw_firmware);
EXPECT_TRUE(result.saw_set_report_reply);
ASSERT_GE(result.output.callback_count, 1U);
EXPECT_EQ(result.output.last.kind, lvh::GamepadOutputKind::rumble);
EXPECT_EQ(result.output.last.low_frequency_rumble, 0x5656);
EXPECT_EQ(result.output.last.high_frequency_rumble, 0x1212);
}
TEST_F(LinuxBackendTest, SocketpairBackedDualShock4BluetoothFramesReports) {
const auto result = lvh::detail::test::linux_dualshock4_bluetooth_uhid_socketpair_reports();
EXPECT_TRUE(result.create_status.ok()) << result.create_status.message();
EXPECT_TRUE(result.close_status.ok()) << result.close_status.message();
EXPECT_TRUE(result.creation.saw_create);
EXPECT_TRUE(result.creation.waited_for_start);
EXPECT_EQ(result.creation.name, "Wireless Controller");
EXPECT_TRUE(result.dualshock4.saw_bluetooth_input);
EXPECT_TRUE(result.dualshock4.saw_calibration);
EXPECT_TRUE(result.dualshock4.saw_pairing);
EXPECT_TRUE(result.dualshock4.saw_feature_crc);
}
TEST_F(LinuxBackendTest, FakeLinuxBackendCreatesAllDeviceTypes) {
const auto unavailable = lvh::detail::test::linux_backend_fake_unavailable_capabilities();
EXPECT_FALSE(unavailable.supports_virtual_hid);
EXPECT_FALSE(unavailable.supports_gamepad);
EXPECT_FALSE(unavailable.supports_output_reports);
#if defined(LIBVIRTUALHID_HAVE_XTEST)
EXPECT_TRUE(unavailable.supports_keyboard);
EXPECT_TRUE(unavailable.supports_mouse);
EXPECT_TRUE(unavailable.supports_xtest_fallback);
#else
EXPECT_FALSE(unavailable.supports_keyboard);
EXPECT_FALSE(unavailable.supports_mouse);
EXPECT_FALSE(unavailable.supports_xtest_fallback);
#endif
EXPECT_EQ(lvh::detail::test::linux_backend_gamepad_fake_open_failure().code(), lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(lvh::detail::test::linux_backend_gamepad_fake_create_failure().code(), lvh::ErrorCode::backend_failure);
const auto keyboard_open_status = lvh::detail::test::linux_backend_keyboard_fake_open_failure();
EXPECT_TRUE(keyboard_open_status.ok() || keyboard_open_status.code() == lvh::ErrorCode::backend_unavailable);
const auto keyboard_create_status = lvh::detail::test::linux_backend_keyboard_fake_create_failure();
EXPECT_TRUE(keyboard_create_status.ok() || keyboard_create_status.code() == lvh::ErrorCode::backend_failure);
EXPECT_EQ(
lvh::detail::test::linux_backend_keyboard_fake_create_failure_without_fallback().code(),
lvh::ErrorCode::backend_failure
);
const auto keyboard_fallback_status = lvh::detail::test::linux_backend_keyboard_fake_fallback_success();
EXPECT_TRUE(keyboard_fallback_status.ok() || keyboard_fallback_status.code() == lvh::ErrorCode::backend_unavailable);
const auto mouse_open_status = lvh::detail::test::linux_backend_mouse_fake_open_failure();
EXPECT_TRUE(mouse_open_status.ok() || mouse_open_status.code() == lvh::ErrorCode::backend_unavailable);
const auto mouse_create_status = lvh::detail::test::linux_backend_mouse_fake_create_failure();
EXPECT_TRUE(mouse_create_status.ok() || mouse_create_status.code() == lvh::ErrorCode::backend_failure);
EXPECT_EQ(
lvh::detail::test::linux_backend_mouse_fake_create_failure_without_fallback().code(),
lvh::ErrorCode::backend_failure
);
const auto mouse_fallback_status = lvh::detail::test::linux_backend_mouse_fake_fallback_success();
EXPECT_TRUE(mouse_fallback_status.ok() || mouse_fallback_status.code() == lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(lvh::detail::test::linux_backend_touchscreen_fake_open_failure().code(), lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(lvh::detail::test::linux_backend_touchscreen_fake_create_failure().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(lvh::detail::test::linux_backend_trackpad_fake_open_failure().code(), lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(lvh::detail::test::linux_backend_trackpad_fake_create_failure().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(lvh::detail::test::linux_backend_pen_tablet_fake_open_failure().code(), lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(lvh::detail::test::linux_backend_pen_tablet_fake_create_failure().code(), lvh::ErrorCode::backend_failure);
const auto result = lvh::detail::test::linux_backend_create_all_fake_success();
EXPECT_TRUE(result.capabilities.supports_virtual_hid);
EXPECT_TRUE(result.capabilities.supports_gamepad);
EXPECT_TRUE(result.capabilities.supports_keyboard);
EXPECT_TRUE(result.capabilities.supports_mouse);
EXPECT_TRUE(result.capabilities.supports_touchscreen);
EXPECT_TRUE(result.capabilities.supports_trackpad);
EXPECT_TRUE(result.capabilities.supports_pen_tablet);
EXPECT_TRUE(result.capabilities.supports_output_reports);
EXPECT_TRUE(result.gamepad_status.ok()) << result.gamepad_status.message();
EXPECT_TRUE(result.gamepad_close_status.ok()) << result.gamepad_close_status.message();
EXPECT_TRUE(result.keyboard_status.ok()) << result.keyboard_status.message();
EXPECT_TRUE(result.keyboard_close_status.ok()) << result.keyboard_close_status.message();
EXPECT_TRUE(result.mouse_status.ok()) << result.mouse_status.message();
EXPECT_TRUE(result.mouse_close_status.ok()) << result.mouse_close_status.message();
EXPECT_TRUE(result.touchscreen_status.ok()) << result.touchscreen_status.message();
EXPECT_TRUE(result.touchscreen_close_status.ok()) << result.touchscreen_close_status.message();
EXPECT_TRUE(result.trackpad_status.ok()) << result.trackpad_status.message();
EXPECT_TRUE(result.trackpad_close_status.ok()) << result.trackpad_close_status.message();
EXPECT_TRUE(result.pen_tablet_status.ok()) << result.pen_tablet_status.message();
EXPECT_TRUE(result.pen_tablet_close_status.ok()) << result.pen_tablet_close_status.message();
}
TEST_F(LinuxBackendTest, OpensUhidGamepadsNonblocking) {
const auto flags = lvh::detail::test::linux_backend_gamepad_open_flags();
EXPECT_EQ(flags & O_ACCMODE, O_RDWR);
EXPECT_NE(flags & O_CLOEXEC, 0);
EXPECT_NE(flags & O_NONBLOCK, 0);
}
TEST_F(LinuxBackendTest, FakeUhidSyscallsCoverFailureBranches) {
EXPECT_EQ(lvh::detail::test::linux_uhid_submit_fake_write_failure().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(lvh::detail::test::linux_uhid_submit_fake_short_write().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(lvh::detail::test::linux_uhid_close_fake_write_failure().code(), lvh::ErrorCode::backend_failure);
EXPECT_EQ(lvh::detail::test::linux_uhid_close_fake_close_failure().code(), lvh::ErrorCode::backend_failure);
EXPECT_TRUE(lvh::detail::test::linux_uhid_read_loop_fake_retry_branches().ok());
EXPECT_TRUE(lvh::detail::test::linux_uhid_read_loop_fake_poll_errors().ok());
EXPECT_TRUE(lvh::detail::test::linux_uhid_read_loop_fake_read_error().ok());
EXPECT_TRUE(lvh::detail::test::linux_uhid_read_loop_fake_output_without_callback().ok());
}
TEST_F(LinuxBackendTest, FakeUinputConstructionCoversCapabilitiesAndFailureBranches) {
using enum lvh::GamepadProfileKind;
const auto has_type = [](const lvh::detail::test::LinuxLibevdevCreationResult &result, std::uint32_t type) {
return std::ranges::find(result.event_types, type) != result.event_types.end();
};
const auto has_property = [](const lvh::detail::test::LinuxLibevdevCreationResult &result, std::uint32_t property) {
return std::ranges::find(result.properties, property) != result.properties.end();
};
const auto find_code = [](const lvh::detail::test::LinuxLibevdevCreationResult &result, std::uint32_t type, std::uint32_t code) {
const auto it = std::ranges::find_if(result.event_codes, [type, code](const auto &event_code) {
return event_code.type == type && event_code.code == code;
});
return it == result.event_codes.end() ? nullptr : std::to_address(it);
};
const auto keyboard = lvh::detail::test::linux_uinput_create_fake_libevdev_device(lvh::DeviceType::keyboard);
ASSERT_TRUE(keyboard.status.ok()) << keyboard.status.message();
EXPECT_EQ(keyboard.name, lvh::profiles::keyboard().name);
EXPECT_EQ(keyboard.bustype, BUS_USB);
EXPECT_TRUE(has_type(keyboard, EV_KEY));
for (const auto code : {KEY_A, KEY_ENTER, KEY_LEFTSHIFT, KEY_F1, KEY_VOLUMEUP, KEY_OK}) {
EXPECT_NE(find_code(keyboard, EV_KEY, code), nullptr) << code;
}
for (const auto code : {BTN_LEFT, BTN_SOUTH, BTN_TOOL_PEN, BTN_TOUCH}) {
EXPECT_EQ(find_code(keyboard, EV_KEY, code), nullptr) << code;
}
constexpr auto unnamed_code = 0x54;
ASSERT_EQ(libevdev_event_code_get_name(EV_KEY, unnamed_code), nullptr);
EXPECT_EQ(find_code(keyboard, EV_KEY, unnamed_code), nullptr);
EXPECT_EQ(keyboard.destroy_count, 1U);
struct GamepadCase {
lvh::GamepadProfileKind kind;
std::uint16_t bustype;
std::uint16_t vendor_id;
std::uint16_t product_id;
bool key_record;
bool sparse_button_slots;
};
constexpr std::array gamepad_cases {
GamepadCase {generic, BUS_USB, 0x1209, 0x0001, true, false},
GamepadCase {xbox_360, BUS_BLUETOOTH, 0x045E, 0x028E, false, true},
GamepadCase {xbox_one, BUS_BLUETOOTH, 0x045E, 0x0B20, false, true},
GamepadCase {xbox_series, BUS_BLUETOOTH, 0x045E, 0x0B13, true, true},
};
constexpr std::array active_buttons {
BTN_SOUTH,
BTN_EAST,
BTN_NORTH,
BTN_WEST,
BTN_TL,
BTN_TR,
BTN_SELECT,
BTN_START,
BTN_MODE,
BTN_THUMBL,
BTN_THUMBR,
};
constexpr std::array reserved_buttons {BTN_C, BTN_Z, BTN_TL2, BTN_TR2};
constexpr std::array dpad_buttons {BTN_DPAD_UP, BTN_DPAD_DOWN, BTN_DPAD_LEFT, BTN_DPAD_RIGHT};
constexpr std::array feedback_codes {FF_RUMBLE, FF_CONSTANT, FF_PERIODIC, FF_SINE, FF_RAMP, FF_GAIN};
for (const auto &[kind, bustype, vendor_id, product_id, key_record, sparse_button_slots] : gamepad_cases) {
const auto expected_profile = lvh::profiles::gamepad_profile(kind);
ASSERT_TRUE(expected_profile.has_value());
const auto gamepad = lvh::detail::test::linux_uinput_create_fake_gamepad(kind);
ASSERT_TRUE(gamepad.status.ok()) << gamepad.status.message();
EXPECT_EQ(gamepad.name, expected_profile->name);
EXPECT_EQ(gamepad.vendor, vendor_id);
EXPECT_EQ(gamepad.bustype, bustype);
EXPECT_EQ(gamepad.product, product_id);
EXPECT_EQ(gamepad.version, expected_profile->version);
EXPECT_TRUE(has_type(gamepad, EV_KEY));
EXPECT_TRUE(has_type(gamepad, EV_ABS));
EXPECT_EQ(has_type(gamepad, EV_FF), expected_profile->capabilities.supports_rumble);
for (const auto button : active_buttons) {
EXPECT_NE(find_code(gamepad, EV_KEY, button), nullptr) << "missing canonical gamepad button " << button;
}
for (const auto button : reserved_buttons) {
const auto expected = sparse_button_slots;
EXPECT_EQ(find_code(gamepad, EV_KEY, button) != nullptr, expected)
<< "unexpected reserved gamepad button slot state for " << button;
}
for (const auto button : dpad_buttons) {
EXPECT_EQ(find_code(gamepad, EV_KEY, button), nullptr)
<< "unexpected directional gamepad button capability for " << button;
}
EXPECT_NE(find_code(gamepad, EV_ABS, ABS_HAT0X), nullptr);
EXPECT_NE(find_code(gamepad, EV_ABS, ABS_HAT0Y), nullptr);
EXPECT_EQ(find_code(gamepad, EV_KEY, KEY_RECORD) != nullptr, key_record);
const auto *left_trigger = find_code(gamepad, EV_ABS, ABS_Z);
ASSERT_NE(left_trigger, nullptr);
EXPECT_EQ(left_trigger->minimum, 0);
EXPECT_EQ(left_trigger->maximum, 255);
for (const auto code : feedback_codes) {
EXPECT_EQ(find_code(gamepad, EV_FF, code) != nullptr, expected_profile->capabilities.supports_rumble);
}
}
const auto xbox_360_result = lvh::detail::test::linux_uinput_create_fake_gamepad(lvh::GamepadProfileKind::xbox_360);
ASSERT_TRUE(xbox_360_result.status.ok()) << xbox_360_result.status.message();
std::vector<std::uint16_t> xbox_360_button_slots;
for (const auto &event_code : xbox_360_result.event_codes) {
if (event_code.type == EV_KEY && event_code.code >= BTN_SOUTH && event_code.code <= BTN_THUMBR) {
xbox_360_button_slots.push_back(event_code.code);
}
}
std::ranges::sort(xbox_360_button_slots);
constexpr std::array expected_xbox_360_button_slots {
BTN_SOUTH,
BTN_EAST,
BTN_C,
BTN_NORTH,
BTN_WEST,
BTN_Z,
BTN_TL,
BTN_TR,
BTN_TL2,
BTN_TR2,
BTN_SELECT,
BTN_START,
BTN_MODE,
BTN_THUMBL,
BTN_THUMBR,
};
ASSERT_EQ(xbox_360_button_slots.size(), expected_xbox_360_button_slots.size());
for (std::size_t index = 0; index < expected_xbox_360_button_slots.size(); ++index) {
EXPECT_EQ(xbox_360_button_slots[index], expected_xbox_360_button_slots[index]) << "button slot " << index;
}
const auto relative_mouse = lvh::detail::test::linux_uinput_create_fake_libevdev_device(lvh::DeviceType::mouse);
ASSERT_TRUE(relative_mouse.status.ok()) << relative_mouse.status.message();
EXPECT_TRUE(has_type(relative_mouse, EV_KEY));
EXPECT_TRUE(has_type(relative_mouse, EV_REL));
EXPECT_FALSE(has_type(relative_mouse, EV_ABS));
EXPECT_FALSE(has_property(relative_mouse, INPUT_PROP_DIRECT));
EXPECT_NE(find_code(relative_mouse, EV_KEY, BTN_LEFT), nullptr);
EXPECT_NE(find_code(relative_mouse, EV_REL, REL_X), nullptr);
EXPECT_NE(find_code(relative_mouse, EV_REL, REL_WHEEL), nullptr);
EXPECT_NE(find_code(relative_mouse, EV_REL, REL_HWHEEL), nullptr);
#if defined(REL_WHEEL_HI_RES)
EXPECT_NE(find_code(relative_mouse, EV_REL, REL_WHEEL_HI_RES), nullptr);
#endif
#if defined(REL_HWHEEL_HI_RES)
EXPECT_NE(find_code(relative_mouse, EV_REL, REL_HWHEEL_HI_RES), nullptr);
#endif
const auto absolute_mouse = lvh::detail::test::linux_uinput_create_fake_absolute_mouse_device();
ASSERT_TRUE(absolute_mouse.status.ok()) << absolute_mouse.status.message();
EXPECT_TRUE(has_type(absolute_mouse, EV_KEY));
EXPECT_TRUE(has_type(absolute_mouse, EV_REL));
EXPECT_TRUE(has_type(absolute_mouse, EV_ABS));
EXPECT_TRUE(has_property(absolute_mouse, INPUT_PROP_DIRECT));
EXPECT_NE(find_code(absolute_mouse, EV_KEY, BTN_LEFT), nullptr);
EXPECT_EQ(find_code(absolute_mouse, EV_REL, REL_X), nullptr);
EXPECT_EQ(find_code(absolute_mouse, EV_REL, REL_Y), nullptr);
EXPECT_NE(find_code(absolute_mouse, EV_REL, REL_WHEEL), nullptr);
EXPECT_NE(find_code(absolute_mouse, EV_REL, REL_HWHEEL), nullptr);
#if defined(REL_WHEEL_HI_RES)
EXPECT_NE(find_code(absolute_mouse, EV_REL, REL_WHEEL_HI_RES), nullptr);
#endif
#if defined(REL_HWHEEL_HI_RES)
EXPECT_NE(find_code(absolute_mouse, EV_REL, REL_HWHEEL_HI_RES), nullptr);
#endif
const auto *mouse_x = find_code(absolute_mouse, EV_ABS, ABS_X);
ASSERT_NE(mouse_x, nullptr);
EXPECT_TRUE(mouse_x->has_absinfo);
EXPECT_EQ(mouse_x->maximum, 65535);
const auto touchscreen = lvh::detail::test::linux_uinput_create_fake_libevdev_device(lvh::DeviceType::touchscreen);
ASSERT_TRUE(touchscreen.status.ok()) << touchscreen.status.message();
EXPECT_TRUE(has_property(touchscreen, INPUT_PROP_DIRECT));
EXPECT_NE(find_code(touchscreen, EV_KEY, BTN_TOUCH), nullptr);
const auto *touch_slot = find_code(touchscreen, EV_ABS, ABS_MT_SLOT);
ASSERT_NE(touch_slot, nullptr);
EXPECT_TRUE(touch_slot->has_absinfo);
EXPECT_EQ(touch_slot->maximum, 15);
const auto trackpad = lvh::detail::test::linux_uinput_create_fake_libevdev_device(lvh::DeviceType::trackpad);
ASSERT_TRUE(trackpad.status.ok()) << trackpad.status.message();
EXPECT_TRUE(has_property(trackpad, INPUT_PROP_POINTER));
EXPECT_TRUE(has_property(trackpad, INPUT_PROP_BUTTONPAD));
EXPECT_NE(find_code(trackpad, EV_KEY, BTN_LEFT), nullptr);
EXPECT_NE(find_code(trackpad, EV_KEY, BTN_TOOL_DOUBLETAP), nullptr);
const auto pen_tablet = lvh::detail::test::linux_uinput_create_fake_libevdev_device(lvh::DeviceType::pen_tablet);
ASSERT_TRUE(pen_tablet.status.ok()) << pen_tablet.status.message();
EXPECT_TRUE(has_property(pen_tablet, INPUT_PROP_POINTER));
EXPECT_TRUE(has_property(pen_tablet, INPUT_PROP_DIRECT));
EXPECT_NE(find_code(pen_tablet, EV_KEY, BTN_TOOL_PEN), nullptr);
const auto *pen_x = find_code(pen_tablet, EV_ABS, ABS_X);
ASSERT_NE(pen_x, nullptr);
EXPECT_TRUE(pen_x->has_absinfo);
EXPECT_EQ(pen_x->maximum, 19200);
EXPECT_EQ(pen_x->fuzz, 1);
EXPECT_EQ(pen_x->resolution, 28);
const auto *pen_pressure = find_code(pen_tablet, EV_ABS, ABS_PRESSURE);
ASSERT_NE(pen_pressure, nullptr);
EXPECT_EQ(pen_pressure->maximum, 4096);
const auto *pen_tilt = find_code(pen_tablet, EV_ABS, ABS_TILT_X);
ASSERT_NE(pen_tilt, nullptr);
EXPECT_EQ(pen_tilt->minimum, -90);
EXPECT_EQ(pen_tilt->maximum, 90);
EXPECT_EQ(pen_tilt->resolution, 28);
EXPECT_EQ(
lvh::detail::test::linux_uinput_create_fake_libevdev_allocation_failure(lvh::DeviceType::mouse).code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_create_fake_libevdev_event_type_failure(lvh::DeviceType::keyboard).code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_create_fake_libevdev_event_code_failure(lvh::DeviceType::mouse).code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_create_fake_libevdev_property_failure(lvh::DeviceType::trackpad).code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_create_fake_libevdev_create_failure(lvh::DeviceType::pen_tablet).code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_keyboard_submit_fake_write_failure().code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(lvh::detail::test::linux_uinput_keyboard_submit_fake_short_write().code(), lvh::ErrorCode::backend_failure);
EXPECT_TRUE(lvh::detail::test::linux_uinput_keyboard_type_text_fake_success().ok());
for (const auto fail_call : {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23}) {
EXPECT_EQ(
lvh::detail::test::linux_uinput_keyboard_type_text_fake_write_failure(fail_call).code(),
lvh::ErrorCode::backend_failure
);
}
EXPECT_EQ(
lvh::detail::test::linux_uinput_keyboard_close_fake_close_failure().code(),
lvh::ErrorCode::backend_failure
);
lvh::MouseEvent event;
event.kind = lvh::MouseEventKind::relative_motion;
event.x = 1;
event.y = 1;
EXPECT_EQ(
lvh::detail::test::linux_uinput_mouse_submit_fake_write_failure(event).code(),
lvh::ErrorCode::backend_failure
);
EXPECT_EQ(
lvh::detail::test::linux_uinput_mouse_submit_fake_short_write(event).code(),
lvh::ErrorCode::backend_failure
);
}
TEST_F(LinuxBackendTest, XTestFallbackCoversKeyboardAndMousePaths) {
const auto keyboard_status = lvh::detail::test::linux_xtest_keyboard_submit_success();
EXPECT_TRUE(keyboard_status.ok() || keyboard_status.code() == lvh::ErrorCode::backend_unavailable);
const auto compose_status = lvh::detail::test::linux_xtest_keyboard_submit_compose_fallback();
#if defined(LIBVIRTUALHID_HAVE_XTEST)
EXPECT_TRUE(compose_status.ok()) << compose_status.message();
#else
EXPECT_EQ(compose_status.code(), lvh::ErrorCode::backend_unavailable);
#endif
const auto keyboard_invalid_status = lvh::detail::test::linux_xtest_keyboard_submit_invalid();
EXPECT_TRUE(keyboard_invalid_status.code() == lvh::ErrorCode::invalid_argument || keyboard_invalid_status.code() == lvh::ErrorCode::backend_unavailable);
const auto keyboard_closed_status = lvh::detail::test::linux_xtest_keyboard_submit_closed();
EXPECT_TRUE(keyboard_closed_status.code() == lvh::ErrorCode::device_closed || keyboard_closed_status.code() == lvh::ErrorCode::backend_unavailable);
const auto keyboard_text_status = lvh::detail::test::linux_xtest_keyboard_type_text_success();
EXPECT_TRUE(keyboard_text_status.ok() || keyboard_text_status.code() == lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(
lvh::detail::test::linux_xtest_keyboard_create_query_failure().code(),
lvh::ErrorCode::backend_unavailable
);
for (const auto fail_call : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}) {
const auto status = lvh::detail::test::linux_xtest_keyboard_type_text_fake_keycode_failure(fail_call);
EXPECT_TRUE(status.code() == lvh::ErrorCode::invalid_argument || status.code() == lvh::ErrorCode::backend_unavailable);
}
const auto mouse_status = lvh::detail::test::linux_xtest_mouse_submit_success();
EXPECT_TRUE(mouse_status.ok() || mouse_status.code() == lvh::ErrorCode::backend_unavailable);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_create_query_failure().code(), lvh::ErrorCode::backend_unavailable);
const auto mouse_closed_status = lvh::detail::test::linux_xtest_mouse_submit_closed();
EXPECT_TRUE(mouse_closed_status.code() == lvh::ErrorCode::device_closed || mouse_closed_status.code() == lvh::ErrorCode::backend_unavailable);
#if defined(LIBVIRTUALHID_HAVE_XTEST)
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x08), XK_BackSpace);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x09), XK_Tab);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x0D), XK_Return);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x10), XK_Shift_L);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x11), XK_Control_L);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x12), XK_Alt_L);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x14), XK_Caps_Lock);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x1B), XK_Escape);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x20), XK_space);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x21), XK_Page_Up);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x22), XK_Page_Down);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x23), XK_End);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x24), XK_Home);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x25), XK_Left);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x26), XK_Up);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x27), XK_Right);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x28), XK_Down);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x2D), XK_Insert);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x2E), XK_Delete);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x5B), XK_Super_L);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x5C), XK_Super_R);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x5D), XK_Menu);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x90), XK_Num_Lock);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x91), XK_Scroll_Lock);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xA1), XK_Shift_R);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xA3), XK_Control_R);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xA5), XK_Alt_R);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xBA), XK_semicolon);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xBB), XK_equal);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xBC), XK_comma);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xBD), XK_minus);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xBE), XK_period);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xBF), XK_slash);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xC0), XK_grave);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xDB), XK_bracketleft);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xDC), XK_backslash);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xDD), XK_bracketright);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0xDE), XK_apostrophe);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x30), XK_0);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x39), XK_9);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x41), XK_a);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x5A), XK_z);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x60), XK_KP_0);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x69), XK_KP_9);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x6A), XK_KP_Multiply);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x6B), XK_KP_Add);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x6D), XK_KP_Subtract);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x6E), XK_KP_Decimal);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x6F), XK_KP_Divide);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x70), XK_F1);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x87), XK_F24);
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x88), 0UL);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(lvh::MouseButton::left), 1);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(lvh::MouseButton::middle), 2);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(lvh::MouseButton::right), 3);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(lvh::MouseButton::side), 8);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(lvh::MouseButton::extra), 9);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(static_cast<lvh::MouseButton>(255)), 1);
#else
EXPECT_EQ(lvh::detail::test::linux_xtest_keysym(0x41), 0UL);
EXPECT_EQ(lvh::detail::test::linux_xtest_mouse_button(lvh::MouseButton::left), 1);
#endif
}
TEST_F(LinuxBackendTest, PlatformRuntimeReportsUnavailableDeviceCreationWhenNodesAreMissing) {
lvh::RuntimeOptions options;
options.backend = lvh::BackendKind::platform_default;
auto runtime = lvh::Runtime::create(options);
if (!runtime->capabilities().supports_gamepad) {
auto gamepad = runtime->create_gamepad(lvh::profiles::xbox_360());
EXPECT_FALSE(gamepad);
EXPECT_EQ(gamepad.status.code(), lvh::ErrorCode::backend_unavailable);
}
if (!runtime->capabilities().supports_keyboard) {
auto keyboard = runtime->create_keyboard();
EXPECT_FALSE(keyboard);
EXPECT_EQ(keyboard.status.code(), lvh::ErrorCode::backend_unavailable);
}
if (!runtime->capabilities().supports_mouse) {
auto mouse = runtime->create_mouse();
EXPECT_FALSE(mouse);
EXPECT_EQ(mouse.status.code(), lvh::ErrorCode::backend_unavailable);
}
}
Reference in new issue View Git Blame Copy Permalink