dlls/dinput8/tests/device.c

   1 /*
   2  * Copyright (c) 2011 Lucas Fialho Zawacki
   3  * Copyright (c) 2006 Vitaliy Margolen
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define DIRECTINPUT_VERSION 0x0800
  21
  22 #define COBJMACROS
  23 #include <windows.h>
  24
  25 #include "wine/test.h"
  26 #include "windef.h"
  27 #include "dinput.h"
  28
  29 struct enum_data {
  30     LPDIRECTINPUT8 pDI;
  31     LPDIACTIONFORMAT lpdiaf;
  32     LPDIRECTINPUTDEVICE8 keyboard;
  33     LPDIRECTINPUTDEVICE8 mouse;
  34     const char* username;
  35     int ndevices;
  36 };
  37
  38 /* Dummy GUID */
  39 static const GUID ACTION_MAPPING_GUID = { 0x1, 0x2, 0x3, { 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb } };
  40
  41 enum {
  42     DITEST_AXIS,
  43     DITEST_BUTTON,
  44     DITEST_KEYBOARDSPACE,
  45     DITEST_MOUSEBUTTON0,
  46     DITEST_YAXIS
  47 };
  48
  49 static DIACTION actionMapping[]=
  50 {
  51   /* axis */
  52   { 0, 0x01008A01 /* DIAXIS_DRIVINGR_STEER */ , 0, { "Steer" } },
  53   /* button */
  54   { 1, 0x01000C01 /* DIBUTTON_DRIVINGR_SHIFTUP */ , 0, { "Upshift" } },
  55   /* keyboard key */
  56   { 2, DIKEYBOARD_SPACE , 0, { "Missile" } },
  57   /* mouse button */
  58   { 3, DIMOUSE_BUTTON0, 0, { "Select" } },
  59   /* mouse axis */
  60   { 4, DIMOUSE_YAXIS, 0, { "Y Axis" } }
  61 };
  62
  63 static void test_device_input(
  64     LPDIRECTINPUTDEVICE8 lpdid,
  65     DWORD event_type,
  66     DWORD event,
  67     DWORD expected
  68 )
  69 {
  70     HRESULT hr;
  71     DIDEVICEOBJECTDATA obj_data;
  72     DWORD data_size = 1;
  73     int i;
  74
  75     hr = IDirectInputDevice8_Acquire(lpdid);
  76     ok (SUCCEEDED(hr), "Failed to acquire device hr=%08x\n", hr);
  77
  78     if (event_type == INPUT_KEYBOARD)
  79         keybd_event( event, DIK_SPACE, 0, 0);
  80
  81     if (event_type == INPUT_MOUSE)
  82         mouse_event( event, 0, 0, 0, 0);
  83
  84     IDirectInputDevice8_Poll(lpdid);
  85     hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
  86
  87     if (data_size != 1)
  88     {
  89         win_skip("We're not able to inject input into Windows dinput8 with events\n");
  90         return;
  91     }
  92
  93     ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%d\n", obj_data.uAppData, expected);
  94
  95     /* Check for buffer owerflow */
  96     for (i = 0; i < 17; i++)
  97         if (event_type == INPUT_KEYBOARD)
  98         {
  99             keybd_event( VK_SPACE, DIK_SPACE, 0, 0);
 100             keybd_event( VK_SPACE, DIK_SPACE, KEYEVENTF_KEYUP, 0);
 101         }
 102         else if (event_type == INPUT_MOUSE)
 103         {
 104             mouse_event(MOUSEEVENTF_LEFTDOWN, 1, 1, 0, 0);
 105             mouse_event(MOUSEEVENTF_LEFTUP, 1, 1, 0, 0);
 106         }
 107
 108     IDirectInputDevice8_Poll(lpdid);
 109
 110     data_size = 1;
 111     hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
 112     ok(hr == DI_BUFFEROVERFLOW, "GetDeviceData() failed: %08x\n", hr);
 113     data_size = 1;
 114     hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
 115     ok(hr == DI_OK && data_size == 1, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size);
 116 }
 117
 118 static void test_build_action_map(
 119     LPDIRECTINPUTDEVICE8 lpdid,
 120     LPDIACTIONFORMAT lpdiaf,
 121     int action_index,
 122     DWORD expected_type,
 123     DWORD expected_inst
 124 )
 125 {
 126     HRESULT hr;
 127     DIACTION *actions;
 128     DWORD instance, type, how;
 129     GUID assigned_to;
 130     DIDEVICEINSTANCEA ddi;
 131
 132     ddi.dwSize = sizeof(ddi);
 133     IDirectInputDevice_GetDeviceInfo(lpdid, &ddi);
 134
 135     hr = IDirectInputDevice8_BuildActionMap(lpdid, lpdiaf, NULL, DIDBAM_INITIALIZE);
 136     ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr);
 137
 138     actions = lpdiaf->rgoAction;
 139     instance = DIDFT_GETINSTANCE(actions[action_index].dwObjID);
 140     type = DIDFT_GETTYPE(actions[action_index].dwObjID);
 141     how = actions[action_index].dwHow;
 142     assigned_to = actions[action_index].guidInstance;
 143
 144     ok (how == DIAH_USERCONFIG || how == DIAH_DEFAULT, "Action was not set dwHow=%08x\n", how);
 145     ok (instance == expected_inst, "Action not mapped correctly instance=%08x expected=%08x\n", instance, expected_inst);
 146     ok (type == expected_type, "Action type not mapped correctly type=%08x expected=%08x\n", type, expected_type);
 147     ok (IsEqualGUID(&assigned_to, &ddi.guidInstance), "Action and device GUID do not match action=%d\n", action_index);
 148 }
 149
 150 static BOOL CALLBACK enumeration_callback(
 151     LPCDIDEVICEINSTANCE lpddi,
 152     LPDIRECTINPUTDEVICE8 lpdid,
 153     DWORD dwFlags,
 154     DWORD dwRemaining,
 155     LPVOID pvRef)
 156 {
 157     HRESULT hr;
 158     DIPROPDWORD dp;
 159     DIPROPRANGE dpr;
 160     DIPROPSTRING dps;
 161     WCHAR usernameW[MAX_PATH];
 162     DWORD username_size = MAX_PATH;
 163     struct enum_data *data = pvRef;
 164     DWORD cnt;
 165     DIDEVICEOBJECTDATA buffer[5];
 166
 167     if (!data) return DIENUM_CONTINUE;
 168
 169     data->ndevices++;
 170
 171     /* Convert username to WCHAR */
 172     if (data->username != NULL)
 173     {
 174         username_size = MultiByteToWideChar(CP_ACP, 0, data->username, -1, usernameW, 0);
 175         MultiByteToWideChar(CP_ACP, 0, data->username, -1, usernameW, username_size);
 176     }
 177     else
 178         GetUserNameW(usernameW, &username_size);
 179
 180     /* collect the mouse and keyboard */
 181     if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysKeyboard))
 182     {
 183         IDirectInputDevice_AddRef(lpdid);
 184         data->keyboard = lpdid;
 185
 186         ok (dwFlags & DIEDBS_MAPPEDPRI1, "Keyboard should be mapped as pri1 dwFlags=%08x\n", dwFlags);
 187     }
 188
 189     if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysMouse))
 190     {
 191         IDirectInputDevice_AddRef(lpdid);
 192         data->mouse = lpdid;
 193
 194         ok (dwFlags & DIEDBS_MAPPEDPRI1, "Mouse should be mapped as pri1 dwFlags=%08x\n", dwFlags);
 195     }
 196
 197     /* Building and setting an action map */
 198     /* It should not use any pre-stored mappings so we use DIDBAM_INITIALIZE */
 199     hr = IDirectInputDevice8_BuildActionMap(lpdid, data->lpdiaf, NULL, DIDBAM_INITIALIZE);
 200     ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr);
 201
 202     /* Device has no data format and thus can't be acquired */
 203     hr = IDirectInputDevice8_Acquire(lpdid);
 204     ok (hr == DIERR_INVALIDPARAM, "Device was acquired before SetActionMap hr=%08x\n", hr);
 205
 206     hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, data->username, 0);
 207     ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr);
 208
 209     /* Some joysticks may have no suitable actions and thus should not be tested */
 210     if (hr == DI_NOEFFECT) return DIENUM_CONTINUE;
 211
 212     /* Test username after SetActionMap */
 213     dps.diph.dwSize = sizeof(dps);
 214     dps.diph.dwHeaderSize = sizeof(DIPROPHEADER);
 215     dps.diph.dwObj = 0;
 216     dps.diph.dwHow  = DIPH_DEVICE;
 217     dps.wsz[0] = '\0';
 218
 219     hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_USERNAME, &dps.diph);
 220     todo_wine ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr);
 221     todo_wine ok (!lstrcmpW(usernameW, dps.wsz), "Username not set correctly expected=%s, got=%s\n", wine_dbgstr_wn(usernameW, -1), wine_dbgstr_wn(dps.wsz, -1));
 222
 223     /* Test buffer size */
 224     memset(&dp, 0, sizeof(dp));
 225     dp.diph.dwSize = sizeof(dp);
 226     dp.diph.dwHeaderSize = sizeof(DIPROPHEADER);
 227     dp.diph.dwHow  = DIPH_DEVICE;
 228
 229     hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_BUFFERSIZE, &dp.diph);
 230     ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr);
 231     ok (dp.dwData == data->lpdiaf->dwBufferSize, "SetActionMap must set the buffer, buffersize=%d\n", dp.dwData);
 232
 233     cnt = 1;
 234     hr = IDirectInputDevice_GetDeviceData(lpdid, sizeof(buffer[0]), buffer, &cnt, 0);
 235     ok(hr == DIERR_NOTACQUIRED, "GetDeviceData() failed hr=%08x\n", hr);
 236
 237     /* Test axis range */
 238     memset(&dpr, 0, sizeof(dpr));
 239     dpr.diph.dwSize = sizeof(dpr);
 240     dpr.diph.dwHeaderSize = sizeof(DIPROPHEADER);
 241     dpr.diph.dwHow  = DIPH_DEVICE;
 242
 243     hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_RANGE, &dpr.diph);
 244     /* Only test if device supports the range property */
 245     if (SUCCEEDED(hr))
 246     {
 247         ok (dpr.lMin == data->lpdiaf->lAxisMin, "SetActionMap must set the min axis range expected=%d got=%d\n", data->lpdiaf->lAxisMin, dpr.lMin);
 248         ok (dpr.lMax == data->lpdiaf->lAxisMax, "SetActionMap must set the max axis range expected=%d got=%d\n", data->lpdiaf->lAxisMax, dpr.lMax);
 249     }
 250
 251     /* SetActionMap has set the data format so now it should work */
 252     hr = IDirectInputDevice8_Acquire(lpdid);
 253     ok (SUCCEEDED(hr), "Acquire failed hr=%08x\n", hr);
 254
 255     cnt = 1;
 256     hr = IDirectInputDevice_GetDeviceData(lpdid, sizeof(buffer[0]), buffer, &cnt, 0);
 257     ok(hr == DI_OK, "GetDeviceData() failed hr=%08x\n", hr);
 258
 259     /* SetActionMap should not work on an acquired device */
 260     hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, NULL, 0);
 261     ok (hr == DIERR_ACQUIRED, "SetActionMap succeeded with an acquired device hr=%08x\n", hr);
 262
 263     return DIENUM_CONTINUE;
 264 }
 265
 266 static void test_action_mapping(void)
 267 {
 268     HRESULT hr;
 269     HINSTANCE hinst = GetModuleHandle(NULL);
 270     LPDIRECTINPUT8 pDI = NULL;
 271     DIACTIONFORMAT af;
 272     struct enum_data data =  {pDI, &af, NULL, NULL, NULL, 0};
 273
 274     hr = CoCreateInstance(&CLSID_DirectInput8, 0, 1, &IID_IDirectInput8A, (LPVOID*)&pDI);
 275     if (hr == DIERR_OLDDIRECTINPUTVERSION ||
 276         hr == DIERR_BETADIRECTINPUTVERSION ||
 277         hr == REGDB_E_CLASSNOTREG)
 278     {
 279         win_skip("ActionMapping requires dinput8\n");
 280         return;
 281     }
 282     ok(SUCCEEDED(hr), "DirectInput8 Create failed: hr=%08x\n", hr);
 283     if (FAILED(hr)) return;
 284
 285     hr = IDirectInput8_Initialize(pDI,hinst, DIRECTINPUT_VERSION);
 286     if (hr == DIERR_OLDDIRECTINPUTVERSION || hr == DIERR_BETADIRECTINPUTVERSION)
 287     {
 288         win_skip("ActionMapping requires dinput8\n");
 289         return;
 290     }
 291     ok(SUCCEEDED(hr), "DirectInput8 Initialize failed: hr=%08x\n", hr);
 292     if (FAILED(hr)) return;
 293
 294     memset (&af, 0, sizeof(af));
 295     af.dwSize = sizeof(af);
 296     af.dwActionSize = sizeof(DIACTION);
 297     af.dwDataSize = 4 * sizeof(actionMapping) / sizeof(actionMapping[0]);
 298     af.dwNumActions = sizeof(actionMapping) / sizeof(actionMapping[0]);
 299     af.rgoAction = actionMapping;
 300     af.guidActionMap = ACTION_MAPPING_GUID;
 301     af.dwGenre = 0x01000000; /* DIVIRTUAL_DRIVING_RACE */
 302     af.dwBufferSize = 32;
 303
 304     /* This enumeration builds and sets the action map for all devices */
 305     hr = IDirectInput8_EnumDevicesBySemantics(pDI, 0, &af, enumeration_callback, &data, DIEDBSFL_ATTACHEDONLY);
 306     ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr);
 307
 308     /* Repeat tests with a non NULL user */
 309     data.username = "Ninja Brian";
 310     hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &af, enumeration_callback, &data, DIEDBSFL_ATTACHEDONLY);
 311     ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr);
 312
 313     if (data.keyboard != NULL)
 314     {
 315         /* Test keyboard BuildActionMap */
 316         test_build_action_map(data.keyboard, data.lpdiaf, DITEST_KEYBOARDSPACE, DIDFT_PSHBUTTON, DIK_SPACE);
 317         /* Test keyboard input */
 318         test_device_input(data.keyboard, INPUT_KEYBOARD, VK_SPACE, 2);
 319
 320         /* Test BuildActionMap with no suitable actions for a device */
 321         IDirectInputDevice_Unacquire(data.keyboard);
 322         af.dwDataSize = 4 * DITEST_KEYBOARDSPACE;
 323         af.dwNumActions = DITEST_KEYBOARDSPACE;
 324
 325         hr = IDirectInputDevice8_BuildActionMap(data.keyboard, data.lpdiaf, NULL, DIDBAM_INITIALIZE);
 326         ok (hr == DI_NOEFFECT, "BuildActionMap should have no effect with no actions hr=%08x\n", hr);
 327
 328         hr = IDirectInputDevice8_SetActionMap(data.keyboard, data.lpdiaf, NULL, 0);
 329         ok (hr == DI_NOEFFECT, "SetActionMap should have no effect with no actions to map hr=%08x\n", hr);
 330
 331         af.dwDataSize = 4 * sizeof(actionMapping) / sizeof(actionMapping[0]);
 332         af.dwNumActions = sizeof(actionMapping) / sizeof(actionMapping[0]);
 333     }
 334
 335     if (data.mouse != NULL)
 336     {
 337         /* Test mouse BuildActionMap */
 338         test_build_action_map(data.mouse, data.lpdiaf, DITEST_MOUSEBUTTON0, DIDFT_PSHBUTTON, 0x03);
 339         test_build_action_map(data.mouse, data.lpdiaf, DITEST_YAXIS, DIDFT_RELAXIS, 0x01);
 340
 341         test_device_input(data.mouse, INPUT_MOUSE, MOUSEEVENTF_LEFTDOWN, 3);
 342     }
 343 }
 344
 345 START_TEST(device)
 346 {
 347     CoInitialize(NULL);
 348
 349     test_action_mapping();
 350
 351     CoUninitialize();
 352 }