Sweden-Number/dlls/xinput1_3/tests/xinput.c

/*
 * The Wine project - Xinput Joystick Library
 * Copyright 2008 Andrew Fenn
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include <windows.h>
#include <stdio.h>

#include "winioctl.h"
#include "xinput.h"
#include "shlwapi.h"
#include "setupapi.h"
#include "ddk/hidsdi.h"
#include "ddk/hidclass.h"
#include "wine/test.h"

static DWORD (WINAPI *pXInputGetState)(DWORD, XINPUT_STATE*);
static DWORD (WINAPI *pXInputGetStateEx)(DWORD, XINPUT_STATE*);
static DWORD (WINAPI *pXInputGetCapabilities)(DWORD,DWORD,XINPUT_CAPABILITIES*);
static DWORD (WINAPI *pXInputSetState)(DWORD, XINPUT_VIBRATION*);
static void  (WINAPI *pXInputEnable)(BOOL);
static DWORD (WINAPI *pXInputGetKeystroke)(DWORD, DWORD, PXINPUT_KEYSTROKE);
static DWORD (WINAPI *pXInputGetDSoundAudioDeviceGuids)(DWORD, GUID*, GUID*);
static DWORD (WINAPI *pXInputGetBatteryInformation)(DWORD, BYTE, XINPUT_BATTERY_INFORMATION*);

static void dump_gamepad(XINPUT_GAMEPAD *data)
{
    trace("-- Gamepad Variables --\n");
    trace("Gamepad.wButtons: %#x\n", data->wButtons);
    trace("Gamepad.bLeftTrigger: %d\n", data->bLeftTrigger);
    trace("Gamepad.bRightTrigger: %d\n", data->bRightTrigger);
    trace("Gamepad.sThumbLX: %d\n", data->sThumbLX);
    trace("Gamepad.sThumbLY: %d\n", data->sThumbLY);
    trace("Gamepad.sThumbRX: %d\n", data->sThumbRX);
    trace("Gamepad.sThumbRY: %d\n\n", data->sThumbRY);
}

static void test_set_state(void)
{
    XINPUT_VIBRATION vibrator;
    DWORD controllerNum;
    DWORD result;

    for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
    {
        ZeroMemory(&vibrator, sizeof(XINPUT_VIBRATION));

        vibrator.wLeftMotorSpeed = 32767;
        vibrator.wRightMotorSpeed = 32767;
        result = pXInputSetState(controllerNum, &vibrator);
        if (result == ERROR_DEVICE_NOT_CONNECTED) continue;

        Sleep(250);
        vibrator.wLeftMotorSpeed = 0;
        vibrator.wRightMotorSpeed = 0;
        result = pXInputSetState(controllerNum, &vibrator);
        ok(result == ERROR_SUCCESS, "XInputSetState returned %lu\n", result);

        /* Disabling XInput here, queueing a vibration and then re-enabling XInput
         * is used to prove that vibrations are auto enabled when resuming XInput.
         * If XInputEnable(1) is removed below the vibration will never play. */
        if (pXInputEnable) pXInputEnable(0);

        Sleep(250);
        vibrator.wLeftMotorSpeed = 65535;
        vibrator.wRightMotorSpeed = 65535;
        result = pXInputSetState(controllerNum, &vibrator);
        ok(result == ERROR_SUCCESS, "XInputSetState returned %lu\n", result);

        if (pXInputEnable) pXInputEnable(1);
        Sleep(250);

        vibrator.wLeftMotorSpeed = 0;
        vibrator.wRightMotorSpeed = 0;
        result = pXInputSetState(controllerNum, &vibrator);
        ok(result == ERROR_SUCCESS, "XInputSetState returned %lu\n", result);
    }

    result = pXInputSetState(XUSER_MAX_COUNT+1, &vibrator);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputSetState returned %lu\n", result);
}

static void test_get_state(void)
{
    XINPUT_STATE state;
    DWORD controllerNum, i, result, good = XUSER_MAX_COUNT;

    for (i = 0; i < (pXInputGetStateEx ? 2 : 1); i++)
    {
        for (controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
        {
            ZeroMemory(&state, sizeof(state));

            if (i == 0)
                result = pXInputGetState(controllerNum, &state);
            else
                result = pXInputGetStateEx(controllerNum, &state);
            ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED,
               "%s returned %lu\n", i == 0 ? "XInputGetState" : "XInputGetStateEx", result);

            if (ERROR_DEVICE_NOT_CONNECTED == result)
            {
                skip("Controller %lu is not connected\n", controllerNum);
                continue;
            }

            trace("-- Results for controller %lu --\n", controllerNum);
            if (i == 0)
            {
                good = controllerNum;
                trace("XInputGetState: %lu\n", result);
            }
            else
                trace("XInputGetStateEx: %lu\n", result);
            trace("State->dwPacketNumber: %lu\n", state.dwPacketNumber);
            dump_gamepad(&state.Gamepad);
        }
    }

    result = pXInputGetState(0, NULL);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned %lu\n", result);

    result = pXInputGetState(XUSER_MAX_COUNT, &state);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned %lu\n", result);

    result = pXInputGetState(XUSER_MAX_COUNT+1, &state);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned %lu\n", result);
    if (pXInputGetStateEx)
    {
        result = pXInputGetStateEx(XUSER_MAX_COUNT, &state);
        ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned %lu\n", result);

        result = pXInputGetStateEx(XUSER_MAX_COUNT+1, &state);
        ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned %lu\n", result);
    }

    if (winetest_interactive && good < XUSER_MAX_COUNT)
    {
        DWORD now = GetTickCount(), packet = 0;
        XINPUT_GAMEPAD *game = &state.Gamepad;

        trace("You have 20 seconds to test the joystick freely\n");
        do
        {
            Sleep(100);
            pXInputGetState(good, &state);
            if (state.dwPacketNumber == packet)
                continue;

            packet = state.dwPacketNumber;
            trace("Buttons 0x%04X Triggers %3d/%3d LT %6d/%6d RT %6d/%6d\n",
                  game->wButtons, game->bLeftTrigger, game->bRightTrigger,
                  game->sThumbLX, game->sThumbLY, game->sThumbRX, game->sThumbRY);
        }
        while(GetTickCount() - now < 20000);
        trace("Test over...\n");
    }
}

static void test_get_keystroke(void)
{
    XINPUT_KEYSTROKE keystroke;
    DWORD controllerNum;
    DWORD result;

    for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
    {
        ZeroMemory(&keystroke, sizeof(XINPUT_KEYSTROKE));

        result = pXInputGetKeystroke(controllerNum, XINPUT_FLAG_GAMEPAD, &keystroke);
        ok(result == ERROR_EMPTY || result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED,
           "XInputGetKeystroke returned %lu\n", result);

        if (ERROR_DEVICE_NOT_CONNECTED == result)
        {
            skip("Controller %lu is not connected\n", controllerNum);
        }
    }

    ZeroMemory(&keystroke, sizeof(XINPUT_KEYSTROKE));
    result = pXInputGetKeystroke(XUSER_MAX_COUNT+1, XINPUT_FLAG_GAMEPAD, &keystroke);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetKeystroke returned %lu\n", result);
}

static void test_get_capabilities(void)
{
    XINPUT_CAPABILITIES capabilities;
    DWORD controllerNum;
    DWORD result;

    for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
    {
        ZeroMemory(&capabilities, sizeof(XINPUT_CAPABILITIES));

        result = pXInputGetCapabilities(controllerNum, XINPUT_FLAG_GAMEPAD, &capabilities);
        ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED, "XInputGetCapabilities returned %lu\n", result);

        if (ERROR_DEVICE_NOT_CONNECTED == result)
        {
            skip("Controller %lu is not connected\n", controllerNum);
            continue;
        }

        /* Important to show that the results changed between 1.3 and 1.4 XInput version */
        dump_gamepad(&capabilities.Gamepad);
    }

    ZeroMemory(&capabilities, sizeof(XINPUT_CAPABILITIES));
    result = pXInputGetCapabilities(XUSER_MAX_COUNT+1, XINPUT_FLAG_GAMEPAD, &capabilities);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetCapabilities returned %lu\n", result);
}

static void test_get_dsoundaudiodevice(void)
{
    DWORD controllerNum;
    DWORD result;
    GUID soundRender, soundCapture;
    GUID testGuid = {0xFFFFFFFF, 0xFFFF, 0xFFFF, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};
    GUID emptyGuid = {0x0, 0x0, 0x0, {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}};

    for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
    {
        soundRender = soundCapture = testGuid;
        result = pXInputGetDSoundAudioDeviceGuids(controllerNum, &soundRender, &soundCapture);
        ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED, "XInputGetDSoundAudioDeviceGuids returned %lu\n", result);

        if (ERROR_DEVICE_NOT_CONNECTED == result)
        {
            skip("Controller %lu is not connected\n", controllerNum);
            continue;
        }

        if (!IsEqualGUID(&soundRender, &emptyGuid))
            ok(!IsEqualGUID(&soundRender, &testGuid), "Broken GUID returned for sound render device\n");
        else
            trace("Headset phone not attached\n");

        if (!IsEqualGUID(&soundCapture, &emptyGuid))
            ok(!IsEqualGUID(&soundCapture, &testGuid), "Broken GUID returned for sound capture device\n");
        else
            trace("Headset microphone not attached\n");
    }

    result = pXInputGetDSoundAudioDeviceGuids(XUSER_MAX_COUNT+1, &soundRender, &soundCapture);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetDSoundAudioDeviceGuids returned %lu\n", result);
}

static void test_get_batteryinformation(void)
{
    DWORD controllerNum;
    DWORD result;
    XINPUT_BATTERY_INFORMATION batteryInfo;

    for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
    {
        ZeroMemory(&batteryInfo, sizeof(XINPUT_BATTERY_INFORMATION));

        result = pXInputGetBatteryInformation(controllerNum, BATTERY_DEVTYPE_GAMEPAD, &batteryInfo);
        ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED, "XInputGetBatteryInformation returned %lu\n", result);

        if (ERROR_DEVICE_NOT_CONNECTED == result)
        {
            ok(batteryInfo.BatteryLevel == BATTERY_TYPE_DISCONNECTED, "Failed to report device as being disconnected.\n");
            skip("Controller %lu is not connected\n", controllerNum);
        }
    }

    result = pXInputGetBatteryInformation(XUSER_MAX_COUNT+1, BATTERY_DEVTYPE_GAMEPAD, &batteryInfo);
    ok(result == ERROR_BAD_ARGUMENTS, "XInputGetBatteryInformation returned %lu\n", result);
}

#define check_member_(file, line, val, exp, fmt, member)               \
        ok_(file, line)((val).member == (exp).member,                  \
                        "got " #member " " fmt ", expected " fmt "\n", \
                        (val).member, (exp).member)
#define check_member(val, exp, fmt, member) check_member_(__FILE__, __LINE__, val, exp, fmt, member)

static void check_hid_caps(DWORD index, HANDLE device,  PHIDP_PREPARSED_DATA preparsed,
                           HIDD_ATTRIBUTES *attrs, HIDP_CAPS *hid_caps)
{
    const HIDP_CAPS expect_hid_caps =
    {
        .Usage = HID_USAGE_GENERIC_GAMEPAD,
        .UsagePage = HID_USAGE_PAGE_GENERIC,
        .InputReportByteLength =
                attrs->VendorID == 0x045e && attrs->ProductID == 0x02ff ? 16 :
                15,
        .OutputReportByteLength = 0,
        .FeatureReportByteLength = 0,
        .NumberLinkCollectionNodes = 4,
        .NumberInputButtonCaps = 1,
        .NumberInputValueCaps = 6,
        .NumberInputDataIndices =
                attrs->VendorID == 0x045e && attrs->ProductID == 0x02ff ? 22 :
                16,
        .NumberFeatureButtonCaps = 0,
        .NumberFeatureValueCaps = 0,
        .NumberFeatureDataIndices = 0,
    };
    const HIDP_BUTTON_CAPS expect_button_caps[] =
    {
        {
            .UsagePage = HID_USAGE_PAGE_BUTTON,
            .BitField = 2,
            .LinkUsage = HID_USAGE_GENERIC_GAMEPAD,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .IsRange = TRUE,
            .IsAbsolute = TRUE,
            .Range.UsageMin = 0x01,
            .Range.UsageMax =
                    attrs->VendorID == 0x045e && attrs->ProductID == 0x02ff ? 0x10 :
                    0x0a,
            .Range.DataIndexMin = 5,
            .Range.DataIndexMax =
                    attrs->VendorID == 0x045e && attrs->ProductID == 0x02ff ? 20 :
                    14,
        },
    };
    const HIDP_VALUE_CAPS expect_value_caps[] =
    {
        {
            .UsagePage = HID_USAGE_PAGE_GENERIC,
            .BitField = 2,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .LinkCollection = 1,
            .IsAbsolute = TRUE,
            .BitSize = 16,
            .ReportCount = 1,
            .LogicalMax = -1,
            .PhysicalMax = -1,
            .NotRange.Usage = HID_USAGE_GENERIC_Y,
            .NotRange.DataIndex = 0,
        },
        {
            .UsagePage = HID_USAGE_PAGE_GENERIC,
            .BitField = 2,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .LinkCollection = 1,
            .IsAbsolute = TRUE,
            .BitSize = 16,
            .ReportCount = 1,
            .LogicalMax = -1,
            .PhysicalMax = -1,
            .NotRange.Usage = HID_USAGE_GENERIC_X,
            .NotRange.DataIndex = 1,
        },
        {
            .UsagePage = HID_USAGE_PAGE_GENERIC,
            .BitField = 2,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .LinkCollection = 2,
            .IsAbsolute = TRUE,
            .BitSize = 16,
            .ReportCount = 1,
            .LogicalMax = -1,
            .PhysicalMax = -1,
            .NotRange.Usage = HID_USAGE_GENERIC_RY,
            .NotRange.DataIndex = 2,
        },
        {
            .UsagePage = HID_USAGE_PAGE_GENERIC,
            .BitField = 2,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .LinkCollection = 2,
            .IsAbsolute = TRUE,
            .BitSize = 16,
            .ReportCount = 1,
            .LogicalMax = -1,
            .PhysicalMax = -1,
            .NotRange.Usage = HID_USAGE_GENERIC_RX,
            .NotRange.DataIndex = 3,
        },
        {
            .UsagePage = HID_USAGE_PAGE_GENERIC,
            .BitField = 2,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .LinkCollection = 3,
            .IsAbsolute = TRUE,
            .BitSize = 16,
            .ReportCount = 1,
            .LogicalMax = -1,
            .PhysicalMax = -1,
            .NotRange.Usage = HID_USAGE_GENERIC_Z,
            .NotRange.DataIndex = 4,
        },
        {
            .UsagePage = HID_USAGE_PAGE_GENERIC,
            .BitField = 66,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .LinkUsage = HID_USAGE_GENERIC_GAMEPAD,
            .IsAbsolute = TRUE,
            .HasNull = TRUE,
            .BitSize = 4,
            .Units = 14,
            .ReportCount = 1,
            .LogicalMin = 1,
            .LogicalMax = 8,
            .PhysicalMin = 0x0000,
            .PhysicalMax = 0x103b,
            .NotRange.Usage = HID_USAGE_GENERIC_HATSWITCH,
            .NotRange.DataIndex =
                    attrs->VendorID == 0x045e && attrs->ProductID == 0x02ff ? 21 :
                    15,
        },
    };
    static const HIDP_LINK_COLLECTION_NODE expect_collections[] =
    {
        {
            .LinkUsage = HID_USAGE_GENERIC_GAMEPAD,
            .LinkUsagePage = HID_USAGE_PAGE_GENERIC,
            .CollectionType = 1,
            .NumberOfChildren = 3,
            .FirstChild = 3,
        },
        { .LinkUsagePage = HID_USAGE_PAGE_GENERIC, .NextSibling = 0, },
        { .LinkUsagePage = HID_USAGE_PAGE_GENERIC, .NextSibling = 1, },
        { .LinkUsagePage = HID_USAGE_PAGE_GENERIC, .NextSibling = 2, },
    };

    HIDP_LINK_COLLECTION_NODE collections[16];
    HIDP_BUTTON_CAPS button_caps[16];
    HIDP_VALUE_CAPS value_caps[16];
    XINPUT_STATE last_state, state;
    XINPUT_CAPABILITIES xi_caps;
    char buffer[200] = {0};
    ULONG length, value;
    USAGE usages[15];
    NTSTATUS status;
    USHORT count;
    DWORD res;
    BOOL ret;
    int i;

    res = pXInputGetCapabilities(index, 0, &xi_caps);
    ok(res == ERROR_SUCCESS, "XInputGetCapabilities %lu returned %lu\n", index, res);

    res = pXInputGetState(index, &state);
    ok(res == ERROR_SUCCESS, "XInputGetState %lu returned %lu\n", index, res);

    ok(hid_caps->UsagePage == HID_USAGE_PAGE_GENERIC, "unexpected usage page %04x\n", hid_caps->UsagePage);
    ok(hid_caps->Usage == HID_USAGE_GENERIC_GAMEPAD, "unexpected usage %04x\n", hid_caps->Usage);

    check_member(*hid_caps, expect_hid_caps, "%04x", Usage);
    check_member(*hid_caps, expect_hid_caps, "%04x", UsagePage);
    check_member(*hid_caps, expect_hid_caps, "%d", InputReportByteLength);
    check_member(*hid_caps, expect_hid_caps, "%d", OutputReportByteLength);
    check_member(*hid_caps, expect_hid_caps, "%d", FeatureReportByteLength);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberLinkCollectionNodes);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberInputButtonCaps);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberInputValueCaps);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberInputDataIndices);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberOutputButtonCaps);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberOutputValueCaps);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberOutputDataIndices);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberFeatureButtonCaps);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberFeatureValueCaps);
    check_member(*hid_caps, expect_hid_caps, "%d", NumberFeatureDataIndices);

    length = hid_caps->NumberLinkCollectionNodes;
    status = HidP_GetLinkCollectionNodes(collections, &length, preparsed);
    ok(status == HIDP_STATUS_SUCCESS, "HidP_GetLinkCollectionNodes returned %#lx\n", status);
    ok(length == ARRAY_SIZE(expect_collections), "got %lu collections\n", length);

    for (i = 0; i < min(length, ARRAY_SIZE(expect_collections)); ++i)
    {
        winetest_push_context("collections[%d]", i);
        check_member(collections[i], expect_collections[i], "%04x", LinkUsage);
        check_member(collections[i], expect_collections[i], "%04x", LinkUsagePage);
        check_member(collections[i], expect_collections[i], "%d", Parent);
        check_member(collections[i], expect_collections[i], "%d", NumberOfChildren);
        check_member(collections[i], expect_collections[i], "%d", NextSibling);
        check_member(collections[i], expect_collections[i], "%d", FirstChild);
        check_member(collections[i], expect_collections[i], "%d", CollectionType);
        check_member(collections[i], expect_collections[i], "%d", IsAlias);
        winetest_pop_context();
    }

    count = hid_caps->NumberInputButtonCaps;
    status = HidP_GetButtonCaps(HidP_Input, button_caps, &count, preparsed);
    ok(status == HIDP_STATUS_SUCCESS, "HidP_GetButtonCaps returned %#lx\n", status);
    ok(count == ARRAY_SIZE(expect_button_caps), "got %d button caps\n", count);

    for (i = 0; i < ARRAY_SIZE(expect_button_caps); ++i)
    {
        winetest_push_context("button_caps[%d]", i);
        check_member(button_caps[i], expect_button_caps[i], "%04x", UsagePage);
        check_member(button_caps[i], expect_button_caps[i], "%d", ReportID);
        check_member(button_caps[i], expect_button_caps[i], "%d", IsAlias);
        check_member(button_caps[i], expect_button_caps[i], "%d", BitField);
        check_member(button_caps[i], expect_button_caps[i], "%d", LinkCollection);
        check_member(button_caps[i], expect_button_caps[i], "%04x", LinkUsage);
        check_member(button_caps[i], expect_button_caps[i], "%04x", LinkUsagePage);
        check_member(button_caps[i], expect_button_caps[i], "%d", IsRange);
        check_member(button_caps[i], expect_button_caps[i], "%d", IsStringRange);
        check_member(button_caps[i], expect_button_caps[i], "%d", IsDesignatorRange);
        check_member(button_caps[i], expect_button_caps[i], "%d", IsAbsolute);

        if (!button_caps[i].IsRange && !expect_button_caps[i].IsRange)
        {
            check_member(button_caps[i], expect_button_caps[i], "%04x", NotRange.Usage);
            check_member(button_caps[i], expect_button_caps[i], "%d", NotRange.DataIndex);
        }
        else if (button_caps[i].IsRange && expect_button_caps[i].IsRange)
        {
            check_member(button_caps[i], expect_button_caps[i], "%04x", Range.UsageMin);
            check_member(button_caps[i], expect_button_caps[i], "%04x", Range.UsageMax);
            check_member(button_caps[i], expect_button_caps[i], "%d", Range.DataIndexMin);
            check_member(button_caps[i], expect_button_caps[i], "%d", Range.DataIndexMax);
        }

        if (!button_caps[i].IsRange && !expect_button_caps[i].IsRange)
            check_member(button_caps[i], expect_button_caps[i], "%d", NotRange.StringIndex);
        else if (button_caps[i].IsStringRange && expect_button_caps[i].IsStringRange)
        {
            check_member(button_caps[i], expect_button_caps[i], "%d", Range.StringMin);
            check_member(button_caps[i], expect_button_caps[i], "%d", Range.StringMax);
        }

        if (!button_caps[i].IsDesignatorRange && !expect_button_caps[i].IsDesignatorRange)
            check_member(button_caps[i], expect_button_caps[i], "%d", NotRange.DesignatorIndex);
        else if (button_caps[i].IsDesignatorRange && expect_button_caps[i].IsDesignatorRange)
        {
            check_member(button_caps[i], expect_button_caps[i], "%d", Range.DesignatorMin);
            check_member(button_caps[i], expect_button_caps[i], "%d", Range.DesignatorMax);
        }
        winetest_pop_context();
    }

    count = hid_caps->NumberInputValueCaps;
    status = HidP_GetValueCaps(HidP_Input, value_caps, &count, preparsed);
    ok(status == HIDP_STATUS_SUCCESS, "HidP_GetValueCaps returned %#lx\n", status);
    ok(count == ARRAY_SIZE(expect_value_caps), "got %d value caps\n", count);

    for (i = 0; i < min(count, ARRAY_SIZE(expect_value_caps)); ++i)
    {
        winetest_push_context("value_caps[%d]", i);
        check_member(value_caps[i], expect_value_caps[i], "%04x", UsagePage);
        check_member(value_caps[i], expect_value_caps[i], "%d", ReportID);
        check_member(value_caps[i], expect_value_caps[i], "%d", IsAlias);
        check_member(value_caps[i], expect_value_caps[i], "%d", BitField);
        check_member(value_caps[i], expect_value_caps[i], "%d", LinkCollection);
        check_member(value_caps[i], expect_value_caps[i], "%d", LinkUsage);
        check_member(value_caps[i], expect_value_caps[i], "%d", LinkUsagePage);
        check_member(value_caps[i], expect_value_caps[i], "%d", IsRange);
        check_member(value_caps[i], expect_value_caps[i], "%d", IsStringRange);
        check_member(value_caps[i], expect_value_caps[i], "%d", IsDesignatorRange);
        check_member(value_caps[i], expect_value_caps[i], "%d", IsAbsolute);

        check_member(value_caps[i], expect_value_caps[i], "%d", HasNull);
        check_member(value_caps[i], expect_value_caps[i], "%d", BitSize);
        check_member(value_caps[i], expect_value_caps[i], "%d", ReportCount);
        check_member(value_caps[i], expect_value_caps[i], "%#lx", UnitsExp);
        check_member(value_caps[i], expect_value_caps[i], "%#lx", Units);
        check_member(value_caps[i], expect_value_caps[i], "%+ld", LogicalMin);
        check_member(value_caps[i], expect_value_caps[i], "%+ld", LogicalMax);
        check_member(value_caps[i], expect_value_caps[i], "%+ld", PhysicalMin);
        check_member(value_caps[i], expect_value_caps[i], "%+ld", PhysicalMax);

        if (!value_caps[i].IsRange && !expect_value_caps[i].IsRange)
        {
            check_member(value_caps[i], expect_value_caps[i], "%04x", NotRange.Usage);
            check_member(value_caps[i], expect_value_caps[i], "%d", NotRange.DataIndex);
        }
        else if (value_caps[i].IsRange && expect_value_caps[i].IsRange)
        {
            check_member(value_caps[i], expect_value_caps[i], "%04x", Range.UsageMin);
            check_member(value_caps[i], expect_value_caps[i], "%04x", Range.UsageMax);
            check_member(value_caps[i], expect_value_caps[i], "%d", Range.DataIndexMin);
            check_member(value_caps[i], expect_value_caps[i], "%d", Range.DataIndexMax);
        }

        if (!value_caps[i].IsRange && !expect_value_caps[i].IsRange)
            check_member(value_caps[i], expect_value_caps[i], "%d", NotRange.StringIndex);
        else if (value_caps[i].IsStringRange && expect_value_caps[i].IsStringRange)
        {
            check_member(value_caps[i], expect_value_caps[i], "%d", Range.StringMin);
            check_member(value_caps[i], expect_value_caps[i], "%d", Range.StringMax);
        }

        if (!value_caps[i].IsDesignatorRange && !expect_value_caps[i].IsDesignatorRange)
            check_member(value_caps[i], expect_value_caps[i], "%d", NotRange.DesignatorIndex);
        else if (value_caps[i].IsDesignatorRange && expect_value_caps[i].IsDesignatorRange)
        {
            check_member(value_caps[i], expect_value_caps[i], "%d", Range.DesignatorMin);
            check_member(value_caps[i], expect_value_caps[i], "%d", Range.DesignatorMax);
        }
        winetest_pop_context();
    }

    status = HidP_InitializeReportForID(HidP_Input, 0, preparsed, buffer, hid_caps->InputReportByteLength);
    ok(status == HIDP_STATUS_SUCCESS, "HidP_InitializeReportForID returned %#lx\n", status);

    SetLastError(0xdeadbeef);
    memset(buffer, 0, sizeof(buffer));
    ret = HidD_GetInputReport(device, buffer, hid_caps->InputReportByteLength);
    ok(!ret, "HidD_GetInputReport succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "HidD_GetInputReport returned error %lu\n", GetLastError());

    if (!winetest_interactive) skip("skipping interactive tests\n");
    /* ReadFile on Xbox One For Windows controller seems to never succeed */
    else if (attrs->VendorID == 0x045e && attrs->ProductID == 0x02ff) skip("skipping interactive tests (Xbox One For Windows)\n");
    else
    {
        res = pXInputGetState(index, &last_state);
        ok(res == ERROR_SUCCESS, "XInputGetState returned %#lx\n", res);

        trace("press A button on gamepad %lu\n", index);

        do
        {
            Sleep(5);
            res = pXInputGetState(index, &state);
            ok(res == ERROR_SUCCESS, "XInputGetState returned %#lx\n", res);
        } while (res == ERROR_SUCCESS && state.dwPacketNumber == last_state.dwPacketNumber);
        ok(state.Gamepad.wButtons & XINPUT_GAMEPAD_A, "unexpected button state %#x\n", state.Gamepad.wButtons);

        /* now read as many reports from the device to get a consistent final state */
        for (i = 0; i < (state.dwPacketNumber - last_state.dwPacketNumber); ++i)
        {
            SetLastError(0xdeadbeef);
            memset(buffer, 0, sizeof(buffer));
            length = hid_caps->InputReportByteLength;
            ret = ReadFile(device, buffer, hid_caps->InputReportByteLength, &length, NULL);
            ok(ret, "ReadFile failed, last error %lu\n", GetLastError());
            ok(length == hid_caps->InputReportByteLength, "ReadFile returned length %lu\n", length);
        }
        last_state = state;

        length = ARRAY_SIZE(usages);
        status = HidP_GetUsages(HidP_Input, HID_USAGE_PAGE_BUTTON, 0, usages, &length, preparsed, buffer, hid_caps->InputReportByteLength);
        ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsages returned %#lx\n", status);
        ok(length == 1, "got length %lu\n", length);
        ok(usages[0] == 1, "got usages[0] %u\n", usages[0]);

        trace("release A on gamepad %lu\n", index);

        do
        {
            Sleep(5);
            res = pXInputGetState(index, &state);
            ok(res == ERROR_SUCCESS, "XInputGetState returned %#lx\n", res);
        } while (res == ERROR_SUCCESS && state.dwPacketNumber == last_state.dwPacketNumber);
        ok(!state.Gamepad.wButtons, "unexpected button state %#x\n", state.Gamepad.wButtons);

        /* now read as many reports from the device to get a consistent final state */
        for (i = 0; i < (state.dwPacketNumber - last_state.dwPacketNumber); ++i)
        {
            SetLastError(0xdeadbeef);
            memset(buffer, 0, sizeof(buffer));
            length = hid_caps->InputReportByteLength;
            ret = ReadFile(device, buffer, hid_caps->InputReportByteLength, &length, NULL);
            ok(ret, "ReadFile failed, last error %lu\n", GetLastError());
            ok(length == hid_caps->InputReportByteLength, "ReadFile returned length %lu\n", length);
        }
        last_state = state;

        length = ARRAY_SIZE(usages);
        status = HidP_GetUsages(HidP_Input, HID_USAGE_PAGE_BUTTON, 0, usages, &length, preparsed, buffer, hid_caps->InputReportByteLength);
        ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsages returned %#lx\n", status);
        ok(length == 0, "got length %lu\n", length);

        trace("press both LT and RT on gamepad %lu\n", index);

        do
        {
            do
            {
                Sleep(5);
                res = pXInputGetState(index, &state);
                ok(res == ERROR_SUCCESS, "XInputGetState returned %#lx\n", res);
            } while (res == ERROR_SUCCESS && state.dwPacketNumber == last_state.dwPacketNumber);

            /* now read as many reports from the device to get a consistent final state */
            for (i = 0; i < (state.dwPacketNumber - last_state.dwPacketNumber); ++i)
            {
                SetLastError(0xdeadbeef);
                memset(buffer, 0, sizeof(buffer));
                length = hid_caps->InputReportByteLength;
                ret = ReadFile(device, buffer, hid_caps->InputReportByteLength, &length, NULL);
                ok(ret, "ReadFile failed, last error %lu\n", GetLastError());
                ok(length == hid_caps->InputReportByteLength, "ReadFile returned length %lu\n", length);
            }
            last_state = state;

            value = 0;
            status = HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_X, &value, preparsed, buffer, hid_caps->InputReportByteLength);
            ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsageValue returned %#lx\n", status);
            ok(value == state.Gamepad.sThumbLX + 32768, "got LX value %lu\n", value);
            value = 0;
            status = HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Y, &value, preparsed, buffer, hid_caps->InputReportByteLength);
            ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsageValue returned %#lx\n", status);
            ok(value == 32767 - state.Gamepad.sThumbLY, "got LY value %lu\n", value);
            value = 0;
            status = HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RX, &value, preparsed, buffer, hid_caps->InputReportByteLength);
            ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsageValue returned %#lx\n", status);
            ok(value == state.Gamepad.sThumbRX + 32768, "got LX value %lu\n", value);
            value = 0;
            status = HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RY, &value, preparsed, buffer, hid_caps->InputReportByteLength);
            ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsageValue returned %#lx\n", status);
            ok(value == 32767 - state.Gamepad.sThumbRY, "got LY value %lu\n", value);
            value = 0;
            status = HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Z, &value, preparsed, buffer, hid_caps->InputReportByteLength);
            ok(status == HIDP_STATUS_SUCCESS, "HidP_GetUsageValue returned %#lx\n", status);
            ok(value == 32768 + (state.Gamepad.bLeftTrigger - state.Gamepad.bRightTrigger) * 128, "got Z value %lu (RT %d, LT %d)\n",
               value, state.Gamepad.bRightTrigger, state.Gamepad.bLeftTrigger);
            value = 0;
            status = HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RZ, &value, preparsed, buffer, hid_caps->InputReportByteLength);
            ok(status == HIDP_STATUS_USAGE_NOT_FOUND, "HidP_GetUsageValue returned %#lx\n", status);
        } while (ret && (state.Gamepad.bRightTrigger != 255 || state.Gamepad.bLeftTrigger != 255));
    }
}

static BOOL try_open_hid_device(const WCHAR *path, HANDLE *device, PHIDP_PREPARSED_DATA *preparsed,
                                HIDD_ATTRIBUTES *attrs, HIDP_CAPS *caps)
{
    PHIDP_PREPARSED_DATA preparsed_data = NULL;
    HANDLE device_file;

    device_file = CreateFileW(path, FILE_READ_ACCESS | FILE_WRITE_ACCESS, FILE_SHARE_READ | FILE_SHARE_WRITE,
                              NULL, OPEN_EXISTING, 0, NULL);
    if (device_file == INVALID_HANDLE_VALUE) return FALSE;

    if (!HidD_GetPreparsedData(device_file, &preparsed_data)) goto failed;
    if (!HidD_GetAttributes(device_file, attrs)) goto failed;
    if (HidP_GetCaps(preparsed_data, caps) != HIDP_STATUS_SUCCESS) goto failed;

    *device = device_file;
    *preparsed = preparsed_data;
    return TRUE;

failed:
    CloseHandle(device_file);
    HidD_FreePreparsedData(preparsed_data);
    return FALSE;
}

static void test_hid_reports(void)
{
    static const WCHAR prefix[] = L"\\\\?\\HID#VID_0000&PID_0000";
    char buffer[sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W) + MAX_PATH * sizeof(WCHAR)];
    SP_DEVICE_INTERFACE_DETAIL_DATA_W *detail = (void *)buffer;
    SP_DEVICE_INTERFACE_DATA iface = {sizeof(iface)};
    SP_DEVINFO_DATA devinfo = {sizeof(devinfo)};
    PHIDP_PREPARSED_DATA preparsed;
    HIDD_ATTRIBUTES attrs;
    HIDP_CAPS caps;
    HDEVINFO set;
    HANDLE device;
    UINT32 i = 0, cnt = 0;
    GUID hid;

    HidD_GetHidGuid(&hid);

    set = SetupDiGetClassDevsW(&hid, NULL, NULL, DIGCF_DEVICEINTERFACE);
    ok(set != INVALID_HANDLE_VALUE, "SetupDiGetClassDevsW failed, error %lu\n", GetLastError());

    while (SetupDiEnumDeviceInterfaces(set, NULL, &hid, i++, &iface))
    {
        detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
        if (!SetupDiGetDeviceInterfaceDetailW(set, &iface, detail, sizeof(buffer), NULL, &devinfo))
            continue;

        if (!try_open_hid_device(detail->DevicePath, &device, &preparsed, &attrs, &caps))
            continue;

        if (wcslen(detail->DevicePath) <= wcslen(prefix) ||
            wcsnicmp(detail->DevicePath + wcslen(prefix), L"&IG_", 4 ))
            continue;

        trace("found xinput HID device %s\n", wine_dbgstr_w(detail->DevicePath));
        check_hid_caps(cnt++, device, preparsed, &attrs, &caps);

        CloseHandle(device);
        HidD_FreePreparsedData(preparsed);
    }

    SetupDiDestroyDeviceInfoList(set);
}

START_TEST(xinput)
{
    struct
    {
        const char *name;
        int version;
    } libs[] = {
        { "xinput1_1.dll",   1 },
        { "xinput1_2.dll",   2 },
        { "xinput1_3.dll",   3 },
        { "xinput1_4.dll",   4 },
        { "xinput9_1_0.dll", 0 } /* legacy for XP/Vista */
    };
    HMODULE hXinput;
    void *pXInputGetStateEx_Ordinal;
    int i;

    for (i = 0; i < ARRAY_SIZE(libs); i++)
    {
        hXinput = LoadLibraryA( libs[i].name );

        if (!hXinput)
        {
            win_skip("Could not load %s\n", libs[i].name);
            continue;
        }
        trace("Testing %s\n", libs[i].name);

        pXInputEnable = (void*)GetProcAddress(hXinput, "XInputEnable");
        pXInputSetState = (void*)GetProcAddress(hXinput, "XInputSetState");
        pXInputGetState = (void*)GetProcAddress(hXinput, "XInputGetState");
        pXInputGetStateEx = (void*)GetProcAddress(hXinput, "XInputGetStateEx"); /* Win >= 8 */
        pXInputGetStateEx_Ordinal = (void*)GetProcAddress(hXinput, (LPCSTR) 100);
        pXInputGetKeystroke = (void*)GetProcAddress(hXinput, "XInputGetKeystroke");
        pXInputGetCapabilities = (void*)GetProcAddress(hXinput, "XInputGetCapabilities");
        pXInputGetDSoundAudioDeviceGuids = (void*)GetProcAddress(hXinput, "XInputGetDSoundAudioDeviceGuids");
        pXInputGetBatteryInformation = (void*)GetProcAddress(hXinput, "XInputGetBatteryInformation");

        /* XInputGetStateEx may not be present by name, use ordinal in this case */
        if (!pXInputGetStateEx)
            pXInputGetStateEx = pXInputGetStateEx_Ordinal;

        test_hid_reports();
        test_set_state();
        test_get_state();
        test_get_capabilities();

        if (libs[i].version != 4)
            test_get_dsoundaudiodevice();
        else
            ok(!pXInputGetDSoundAudioDeviceGuids, "XInputGetDSoundAudioDeviceGuids exists in %s\n", libs[i].name);

        if (libs[i].version > 2)
        {
            test_get_keystroke();
            test_get_batteryinformation();
            ok(pXInputGetStateEx != NULL, "XInputGetStateEx not found in %s\n", libs[i].name);
        }
        else
        {
            ok(!pXInputGetKeystroke, "XInputGetKeystroke exists in %s\n", libs[i].name);
            ok(!pXInputGetStateEx, "XInputGetStateEx exists in %s\n", libs[i].name);
            ok(!pXInputGetBatteryInformation, "XInputGetBatteryInformation exists in %s\n", libs[i].name);
            if (libs[i].version == 0)
                ok(!pXInputEnable, "XInputEnable exists in %s\n", libs[i].name);
        }

        FreeLibrary(hXinput);
    }
}