Add SDL DualSense tests and helpers

Add CI/Codecov/Stars badges to README and update wording to mention generic and DualSense gamepads. In tests, add several standard includes and introduce SDL_GameController RAII alias and a SdlGamepadConsumerCase struct. Add helper functions (configure_sdl_hidapi_hints, create_sdl_gamepad, wait_for_sdl_controller_input, expect_sdl_joystick_profile) and two reusable test runners (run_sdl_uhid_joystick_test, run_sdl_dualsense_controller_test). Refactor the existing SDL UHID gamepad test to use the new runner and add dedicated DualSense USB and Bluetooth tests, plus no-op stubs for non-Linux builds.

Author: ReenigneArcher

README.md

@@ -1,5 +1,9 @@
 # libvirtualhid
 
+[![GitHub Workflow Status (CI)](https://img.shields.io/github/actions/workflow/status/lizardbyte/libvirtualhid/ci.yml.svg?branch=master&label=CI%20build&logo=github&style=for-the-badge)](https://github.com/LizardByte/libvirtualhid/actions/workflows/ci.yml?query=branch%3Amaster)
+[![Codecov](https://img.shields.io/codecov/c/gh/LizardByte/libvirtualhid?token=2MeMpktxpv&style=for-the-badge&logo=codecov&label=codecov)](https://codecov.io/gh/LizardByte/libvirtualhid)
+[![GitHub stars](https://img.shields.io/github/stars/lizardbyte/libvirtualhid.svg?logo=github&style=for-the-badge)](https://github.com/LizardByte/libvirtualhid)
+
 `libvirtualhid` is a planned cross-platform C++ library for creating virtual HID
 input devices for remote streaming hosts and similar low-latency input
 applications.
@@ -345,7 +349,7 @@ third-party/googletest/       GoogleTest submodule
 - [x] Support output report callbacks for rumble and profile-specific feedback.
 - [x] Add X11/XTest fallback support for keyboard and mouse only.
 - [x] Add examples and integration tests that validate virtual device visibility
-  through SDL2 for gamepads and libinput for keyboard/mouse.
+  through SDL2 for generic and DualSense gamepads and libinput for keyboard/mouse.
 - [x] Document required Linux permissions and sample udev rules.
 
 ### Phase 2B: Linux inputtino Parity
@@ -371,9 +375,9 @@ third-party/googletest/       GoogleTest submodule
 - [x] Keep gamepad feedback on UHID output reports. There is no uinput-backed
   gamepad path in this library; if one is added later, it must implement Linux
   force-feedback upload, erase, playback, and gain handling.
-- [x] Expand Linux consumer tests so SDL2 validates controller-specific behavior
-  and libinput validates keyboard, mouse, touchscreen, trackpad, and pen tablet
-  events.
+- [x] Expand Linux consumer tests so SDL2 validates generic joystick input and
+  DualSense USB/Bluetooth controller-specific behavior, and libinput validates
+  keyboard, mouse, touchscreen, trackpad, and pen tablet events.
 
 ### Phase 2C: Linux uinput Hardening
 

tests/fixtures/linux_backend_test_hooks.cpp

@@ -5,12 +5,26 @@
 
 // standard includes
 #include <algorithm>
+#include <array>
 #include <atomic>
 #include <cerrno>
 #include <chrono>
+#include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <numbers>
+#include <optional>
+#include <set>
+#include <sstream>
 #include <string>
+#include <system_error>
 #include <thread>
 #include <utility>
 #include <vector>

tests/unit/test_linux_consumers.cpp

@@ -51,8 +51,20 @@ namespace {
 #if defined(__linux__)
   using LibinputContext = std::unique_ptr<libinput, void (*)(libinput *)>;
   using LibinputEvent = std::unique_ptr<libinput_event, void (*)(libinput_event *)>;
+  using SdlGameController = std::unique_ptr<SDL_GameController, void (*)(SDL_GameController *)>;
   using SdlJoystick = std::unique_ptr<SDL_Joystick, void (*)(SDL_Joystick *)>;
 
+  /**
+   * @brief SDL-visible gamepad case.
+   */
+  struct SdlGamepadConsumerCase {
+    lvh::DeviceProfile profile;
+    std::string_view name_suffix;
+    std::string_view stable_id;
+    int minimum_buttons = 1;
+    int minimum_axes = 2;
+  };
+
   /**
    * @brief Execute cleanup code when a scope exits.
    */
@@ -229,6 +241,139 @@ namespace {
     return false;
   }
 
+  bool wait_for_sdl_controller_input(SDL_GameController *controller) {
+    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds {3};
+
+    while (std::chrono::steady_clock::now() < deadline) {
+      SDL_GameControllerUpdate();
+      pump_sdl_events();
+
+      const auto button_pressed = SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_A) != 0;
+      const auto left_x = std::abs(static_cast<int>(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX)));
+      const auto left_y = std::abs(static_cast<int>(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY)));
+
+      if (button_pressed && (left_x > 8000 || left_y > 8000)) {
+        return true;
+      }
+
+      std::this_thread::sleep_for(std::chrono::milliseconds {50});
+    }
+
+    return false;
+  }
+
+  void configure_sdl_hidapi_hints() {
+    SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
+    SDL_SetHint("SDL_JOYSTICK_HIDAPI", "1");
+    SDL_SetHint("SDL_JOYSTICK_HIDAPI_PS5", "1");
+  }
+
+  lvh::GamepadCreationResult create_sdl_gamepad(lvh::Runtime &runtime, SdlGamepadConsumerCase test_case) {
+    lvh::CreateGamepadOptions options;
+    options.profile = std::move(test_case.profile);
+    options.profile.name = unique_device_name(test_case.name_suffix);
+    options.metadata.stable_id = std::string {test_case.stable_id};
+
+    return runtime.create_gamepad(options);
+  }
+
+  void expect_sdl_joystick_profile(SDL_Joystick *joystick, const lvh::DeviceProfile &profile, int minimum_buttons, int minimum_axes) {
+    EXPECT_EQ(SDL_JoystickGetVendor(joystick), profile.vendor_id);
+    EXPECT_EQ(SDL_JoystickGetProduct(joystick), profile.product_id);
+    EXPECT_GE(SDL_JoystickNumButtons(joystick), minimum_buttons);
+    EXPECT_GE(SDL_JoystickNumAxes(joystick), minimum_axes);
+  }
+
+  void run_sdl_uhid_joystick_test(SdlGamepadConsumerCase test_case) {
+    configure_sdl_hidapi_hints();
+    ASSERT_EQ(SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_EVENTS), 0) << SDL_GetError();
+    ScopeExit sdl_quit {[]() {
+      SDL_Quit();
+    }};
+
+    lvh::RuntimeOptions runtime_options;
+    runtime_options.backend = lvh::BackendKind::platform_default;
+    auto runtime = lvh::Runtime::create(runtime_options);
+    ASSERT_TRUE(runtime->capabilities().supports_gamepad);
+
+    const auto expected_profile = [&test_case]() {
+      auto profile = test_case.profile;
+      profile.name = unique_device_name(test_case.name_suffix);
+      return profile;
+    }();
+
+    auto created = create_sdl_gamepad(*runtime, test_case);
+    ASSERT_TRUE(created) << created.status.message();
+
+    const auto joystick_index = wait_for_sdl_joystick(expected_profile);
+    ASSERT_GE(joystick_index, 0);
+
+    SdlJoystick joystick {SDL_JoystickOpen(joystick_index), SDL_JoystickClose};
+    ASSERT_NE(joystick.get(), nullptr) << SDL_GetError();
+    expect_sdl_joystick_profile(
+      joystick.get(),
+      expected_profile,
+      test_case.minimum_buttons,
+      test_case.minimum_axes
+    );
+
+    lvh::GamepadState state;
+    state.buttons.set(lvh::GamepadButton::a);
+    state.left_stick = {0.75F, -0.5F};
+    ASSERT_TRUE(created.gamepad->submit(state).ok());
+
+    EXPECT_TRUE(wait_for_sdl_gamepad_input(joystick.get())) << describe_sdl_state(joystick.get());
+  }
+
+  void run_sdl_dualsense_controller_test(SdlGamepadConsumerCase test_case) {
+    configure_sdl_hidapi_hints();
+    ASSERT_EQ(SDL_Init(SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK | SDL_INIT_EVENTS), 0) << SDL_GetError();
+    ScopeExit sdl_quit {[]() {
+      SDL_Quit();
+    }};
+
+    lvh::RuntimeOptions runtime_options;
+    runtime_options.backend = lvh::BackendKind::platform_default;
+    auto runtime = lvh::Runtime::create(runtime_options);
+    ASSERT_TRUE(runtime->capabilities().supports_gamepad);
+
+    const auto expected_profile = [&test_case]() {
+      auto profile = test_case.profile;
+      profile.name = unique_device_name(test_case.name_suffix);
+      return profile;
+    }();
+
+    auto created = create_sdl_gamepad(*runtime, test_case);
+    ASSERT_TRUE(created) << created.status.message();
+
+    const auto joystick_index = wait_for_sdl_joystick(expected_profile);
+    ASSERT_GE(joystick_index, 0);
+    ASSERT_EQ(SDL_IsGameController(joystick_index), SDL_TRUE) << SDL_GetError();
+
+    SdlGameController controller {SDL_GameControllerOpen(joystick_index), SDL_GameControllerClose};
+    ASSERT_NE(controller.get(), nullptr) << SDL_GetError();
+
+    auto *joystick = SDL_GameControllerGetJoystick(controller.get());
+    ASSERT_NE(joystick, nullptr) << SDL_GetError();
+    expect_sdl_joystick_profile(
+      joystick,
+      expected_profile,
+      test_case.minimum_buttons,
+      test_case.minimum_axes
+    );
+
+    lvh::GamepadState state;
+    state.buttons.set(lvh::GamepadButton::a);
+    state.left_stick = {0.75F, -0.5F};
+    state.acceleration = lvh::Vector3 {.x = 1.0F, .y = 2.0F, .z = 3.0F};
+    state.gyroscope = lvh::Vector3 {.x = 4.0F, .y = 5.0F, .z = 6.0F};
+    state.battery = lvh::GamepadBattery {.state = lvh::GamepadBatteryState::charging, .percentage = 80};
+    state.touchpad_contacts[0] = {.id = 1, .active = true, .x = 0.5F, .y = 0.25F};
+    ASSERT_TRUE(created.gamepad->submit(state).ok());
+
+    EXPECT_TRUE(wait_for_sdl_controller_input(controller.get())) << describe_sdl_state(joystick);
+  }
+
   void destroy_libinput_event(libinput_event *event) {
     if (event != nullptr) {
       libinput_event_destroy(event);
@@ -306,39 +451,35 @@ namespace {
 TEST_F(LinuxConsumerTest, SdlSeesUhidGamepadButtonAndAxisInput) {
   ASSERT_TRUE(HasReadableWritableDeviceNode("/dev/uhid"));
 
-  SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
-  ASSERT_EQ(SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_EVENTS), 0) << SDL_GetError();
-  ScopeExit sdl_quit {[]() {
-    SDL_Quit();
-  }};
-
-  lvh::RuntimeOptions runtime_options;
-  runtime_options.backend = lvh::BackendKind::platform_default;
-  auto runtime = lvh::Runtime::create(runtime_options);
-  ASSERT_TRUE(runtime->capabilities().supports_gamepad);
-
-  lvh::CreateGamepadOptions options;
-  options.profile = lvh::profiles::generic_gamepad();
-  options.profile.name = unique_device_name("SDL Gamepad");
-  options.metadata.stable_id = "libvirtualhid-sdl-gamepad-test";
-
-  auto created = runtime->create_gamepad(options);
-  ASSERT_TRUE(created) << created.status.message();
+  run_sdl_uhid_joystick_test({
+    .profile = lvh::profiles::generic_gamepad(),
+    .name_suffix = "SDL Gamepad",
+    .stable_id = "libvirtualhid-sdl-gamepad-test",
+  });
+}
 
-  const auto joystick_index = wait_for_sdl_joystick(options.profile);
-  ASSERT_GE(joystick_index, 0);
+TEST_F(LinuxConsumerTest, SdlSeesDualSenseUsbControllerBehavior) {
+  ASSERT_TRUE(HasReadableWritableDeviceNode("/dev/uhid"));
 
-  SdlJoystick joystick {SDL_JoystickOpen(joystick_index), SDL_JoystickClose};
-  ASSERT_NE(joystick.get(), nullptr) << SDL_GetError();
-  EXPECT_GE(SDL_JoystickNumButtons(joystick.get()), 1);
-  EXPECT_GE(SDL_JoystickNumAxes(joystick.get()), 2);
+  run_sdl_dualsense_controller_test({
+    .profile = lvh::profiles::dualsense_usb(),
+    .name_suffix = "SDL DualSense USB",
+    .stable_id = "02:00:00:00:00:01",
+    .minimum_buttons = 10,
+    .minimum_axes = 4,
+  });
+}
 
-  lvh::GamepadState state;
-  state.buttons.set(lvh::GamepadButton::a);
-  state.left_stick = {0.75F, -0.5F};
-  ASSERT_TRUE(created.gamepad->submit(state).ok());
+TEST_F(LinuxConsumerTest, SdlSeesDualSenseBluetoothControllerBehavior) {
+  ASSERT_TRUE(HasReadableWritableDeviceNode("/dev/uhid"));
 
-  EXPECT_TRUE(wait_for_sdl_gamepad_input(joystick.get())) << describe_sdl_state(joystick.get());
+  run_sdl_dualsense_controller_test({
+    .profile = lvh::profiles::dualsense_bluetooth(),
+    .name_suffix = "SDL DualSense Bluetooth",
+    .stable_id = "02:00:00:00:00:02",
+    .minimum_buttons = 10,
+    .minimum_axes = 4,
+  });
 }
 
 TEST_F(LinuxConsumerTest, LibinputSeesUinputKeyboardKeys) {
@@ -569,6 +710,10 @@ TEST_F(LinuxConsumerTest, LibinputSeesUinputPenTabletTool) {
 #else
 TEST_F(LinuxConsumerTest, SdlSeesUhidGamepadButtonAndAxisInput) {}
 
+TEST_F(LinuxConsumerTest, SdlSeesDualSenseUsbControllerBehavior) {}
+
+TEST_F(LinuxConsumerTest, SdlSeesDualSenseBluetoothControllerBehavior) {}
+
 TEST_F(LinuxConsumerTest, LibinputSeesUinputKeyboardKeys) {}
 
 TEST_F(LinuxConsumerTest, LibinputSeesUinputMouseMotionAndButtons) {}