modules/rostests/winetests/setupapi/devinst.c

   1 /*
   2  * Devinst tests
   3  *
   4  * Copyright 2006 Christian Gmeiner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "guiddef.h"
  30 #include "setupapi.h"
  31
  32 #include "wine/test.h"
  33
  34 static BOOL is_wow64;
  35
  36 /* function pointers */
  37 static HDEVINFO (WINAPI *pSetupDiCreateDeviceInfoList)(GUID*,HWND);
  38 static HDEVINFO (WINAPI *pSetupDiCreateDeviceInfoListExW)(GUID*,HWND,PCWSTR,PVOID);
  39 static BOOL     (WINAPI *pSetupDiCreateDeviceInterfaceA)(HDEVINFO, PSP_DEVINFO_DATA, const GUID *, PCSTR, DWORD, PSP_DEVICE_INTERFACE_DATA);
  40 static BOOL     (WINAPI *pSetupDiCallClassInstaller)(DI_FUNCTION, HDEVINFO, PSP_DEVINFO_DATA);
  41 static BOOL     (WINAPI *pSetupDiDestroyDeviceInfoList)(HDEVINFO);
  42 static BOOL     (WINAPI *pSetupDiEnumDeviceInfo)(HDEVINFO, DWORD, PSP_DEVINFO_DATA);
  43 static BOOL     (WINAPI *pSetupDiEnumDeviceInterfaces)(HDEVINFO, PSP_DEVINFO_DATA, const GUID *, DWORD, PSP_DEVICE_INTERFACE_DATA);
  44 static BOOL     (WINAPI *pSetupDiGetINFClassA)(PCSTR, LPGUID, PSTR, DWORD, PDWORD);
  45 static BOOL     (WINAPI *pSetupDiInstallClassA)(HWND, PCSTR, DWORD, HSPFILEQ);
  46 static HKEY     (WINAPI *pSetupDiOpenClassRegKeyExA)(GUID*,REGSAM,DWORD,PCSTR,PVOID);
  47 static HKEY     (WINAPI *pSetupDiOpenDevRegKey)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM);
  48 static HKEY     (WINAPI *pSetupDiCreateDevRegKeyW)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, HINF, PCWSTR);
  49 static BOOL     (WINAPI *pSetupDiCreateDeviceInfoA)(HDEVINFO, PCSTR, GUID *, PCSTR, HWND, DWORD, PSP_DEVINFO_DATA);
  50 static BOOL     (WINAPI *pSetupDiCreateDeviceInfoW)(HDEVINFO, PCWSTR, GUID *, PCWSTR, HWND, DWORD, PSP_DEVINFO_DATA);
  51 static BOOL     (WINAPI *pSetupDiGetDeviceInstanceIdA)(HDEVINFO, PSP_DEVINFO_DATA, PSTR, DWORD, PDWORD);
  52 static BOOL     (WINAPI *pSetupDiGetDeviceInterfaceDetailA)(HDEVINFO, PSP_DEVICE_INTERFACE_DATA, PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA);
  53 static BOOL     (WINAPI *pSetupDiGetDeviceInterfaceDetailW)(HDEVINFO, PSP_DEVICE_INTERFACE_DATA, PSP_DEVICE_INTERFACE_DETAIL_DATA_W, DWORD, PDWORD, PSP_DEVINFO_DATA);
  54 static BOOL     (WINAPI *pSetupDiRegisterDeviceInfo)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, PSP_DETSIG_CMPPROC, PVOID, PSP_DEVINFO_DATA);
  55 static HDEVINFO (WINAPI *pSetupDiGetClassDevsA)(const GUID *, LPCSTR, HWND, DWORD);
  56 static HDEVINFO (WINAPI *pSetupDiGetClassDevsW)(const GUID *, LPCWSTR, HWND, DWORD);
  57 static BOOL     (WINAPI *pSetupDiSetDeviceRegistryPropertyA)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, const BYTE *, DWORD);
  58 static BOOL     (WINAPI *pSetupDiSetDeviceRegistryPropertyW)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, const BYTE *, DWORD);
  59 static BOOL     (WINAPI *pSetupDiGetDeviceRegistryPropertyA)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD);
  60 static BOOL     (WINAPI *pSetupDiGetDeviceRegistryPropertyW)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD);
  61 static BOOL     (WINAPI *pSetupDiRemoveDevice)(HDEVINFO, PSP_DEVINFO_DATA);
  62 static BOOL     (WINAPI *pSetupDiRemoveDeviceInterface)(HDEVINFO, PSP_DEVICE_INTERFACE_DATA);
  63 static BOOL     (WINAPI *pIsWow64Process)(HANDLE, PBOOL);
  64
  65 /* This is a unique guid for testing purposes */
  66 static GUID guid = {0x6a55b5a4, 0x3f65, 0x11db, {0xb7,0x04,0x00,0x11,0x95,0x5c,0x2b,0xdb}};
  67
  68 static void init_function_pointers(void)
  69 {
  70     HMODULE hSetupAPI = GetModuleHandleA("setupapi.dll");
  71     HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
  72
  73     pSetupDiCreateDeviceInfoA = (void *)GetProcAddress(hSetupAPI, "SetupDiCreateDeviceInfoA");
  74     pSetupDiCreateDeviceInfoW = (void *)GetProcAddress(hSetupAPI, "SetupDiCreateDeviceInfoW");
  75     pSetupDiCreateDeviceInfoList = (void *)GetProcAddress(hSetupAPI, "SetupDiCreateDeviceInfoList");
  76     pSetupDiCreateDeviceInfoListExW = (void *)GetProcAddress(hSetupAPI, "SetupDiCreateDeviceInfoListExW");
  77     pSetupDiCreateDeviceInterfaceA = (void *)GetProcAddress(hSetupAPI, "SetupDiCreateDeviceInterfaceA");
  78     pSetupDiDestroyDeviceInfoList = (void *)GetProcAddress(hSetupAPI, "SetupDiDestroyDeviceInfoList");
  79     pSetupDiCallClassInstaller = (void *)GetProcAddress(hSetupAPI, "SetupDiCallClassInstaller");
  80     pSetupDiEnumDeviceInfo = (void *)GetProcAddress(hSetupAPI, "SetupDiEnumDeviceInfo");
  81     pSetupDiEnumDeviceInterfaces = (void *)GetProcAddress(hSetupAPI, "SetupDiEnumDeviceInterfaces");
  82     pSetupDiGetDeviceInstanceIdA = (void *)GetProcAddress(hSetupAPI, "SetupDiGetDeviceInstanceIdA");
  83     pSetupDiGetDeviceInterfaceDetailA = (void *)GetProcAddress(hSetupAPI, "SetupDiGetDeviceInterfaceDetailA");
  84     pSetupDiGetDeviceInterfaceDetailW = (void *)GetProcAddress(hSetupAPI, "SetupDiGetDeviceInterfaceDetailW");
  85     pSetupDiInstallClassA = (void *)GetProcAddress(hSetupAPI, "SetupDiInstallClassA");
  86     pSetupDiOpenClassRegKeyExA = (void *)GetProcAddress(hSetupAPI, "SetupDiOpenClassRegKeyExA");
  87     pSetupDiOpenDevRegKey = (void *)GetProcAddress(hSetupAPI, "SetupDiOpenDevRegKey");
  88     pSetupDiCreateDevRegKeyW = (void *)GetProcAddress(hSetupAPI, "SetupDiCreateDevRegKeyW");
  89     pSetupDiRegisterDeviceInfo = (void *)GetProcAddress(hSetupAPI, "SetupDiRegisterDeviceInfo");
  90     pSetupDiGetClassDevsA = (void *)GetProcAddress(hSetupAPI, "SetupDiGetClassDevsA");
  91     pSetupDiGetClassDevsW = (void *)GetProcAddress(hSetupAPI, "SetupDiGetClassDevsW");
  92     pSetupDiGetINFClassA = (void *)GetProcAddress(hSetupAPI, "SetupDiGetINFClassA");
  93     pSetupDiSetDeviceRegistryPropertyA = (void *)GetProcAddress(hSetupAPI, "SetupDiSetDeviceRegistryPropertyA");
  94     pSetupDiSetDeviceRegistryPropertyW = (void *)GetProcAddress(hSetupAPI, "SetupDiSetDeviceRegistryPropertyW");
  95     pSetupDiGetDeviceRegistryPropertyA = (void *)GetProcAddress(hSetupAPI, "SetupDiGetDeviceRegistryPropertyA");
  96     pSetupDiGetDeviceRegistryPropertyW = (void *)GetProcAddress(hSetupAPI, "SetupDiGetDeviceRegistryPropertyW");
  97     pSetupDiRemoveDeviceInterface = (void *)GetProcAddress(hSetupAPI, "SetupDiRemoveDeviceInterface");
  98     pSetupDiRemoveDevice = (void *)GetProcAddress(hSetupAPI, "SetupDiRemoveDevice");
  99     pIsWow64Process = (void *)GetProcAddress(hKernel32, "IsWow64Process");
 100 }
 101
 102 static LSTATUS devinst_RegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey)
 103 {
 104     LONG ret;
 105     DWORD dwMaxSubkeyLen, dwMaxValueLen;
 106     DWORD dwMaxLen, dwSize;
 107     WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
 108     HKEY hSubKey = hKey;
 109
 110     if(lpszSubKey)
 111     {
 112         ret = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 113         if (ret) return ret;
 114     }
 115
 116     /* Get highest length for keys, values */
 117     ret = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
 118             &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
 119     if (ret) goto cleanup;
 120
 121     dwMaxSubkeyLen++;
 122     dwMaxValueLen++;
 123     dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
 124     if (dwMaxLen > sizeof(szNameBuf)/sizeof(WCHAR))
 125     {
 126         /* Name too big: alloc a buffer for it */
 127         if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(WCHAR))))
 128         {
 129             ret = ERROR_NOT_ENOUGH_MEMORY;
 130             goto cleanup;
 131         }
 132     }
 133
 134
 135     /* Recursively delete all the subkeys */
 136     while (TRUE)
 137     {
 138         dwSize = dwMaxLen;
 139         if (RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL,
 140                           NULL, NULL, NULL)) break;
 141
 142         ret = devinst_RegDeleteTreeW(hSubKey, lpszName);
 143         if (ret) goto cleanup;
 144     }
 145
 146     if (lpszSubKey)
 147         ret = RegDeleteKeyW(hKey, lpszSubKey);
 148     else
 149         while (TRUE)
 150         {
 151             dwSize = dwMaxLen;
 152             if (RegEnumValueW(hKey, 0, lpszName, &dwSize,
 153                   NULL, NULL, NULL, NULL)) break;
 154
 155             ret = RegDeleteValueW(hKey, lpszName);
 156             if (ret) goto cleanup;
 157         }
 158
 159 cleanup:
 160     /* Free buffer if allocated */
 161     if (lpszName != szNameBuf)
 162         HeapFree( GetProcessHeap(), 0, lpszName);
 163     if(lpszSubKey)
 164         RegCloseKey(hSubKey);
 165     return ret;
 166 }
 167
 168 static void test_SetupDiCreateDeviceInfoListEx(void)
 169 {
 170     HDEVINFO devlist;
 171     BOOL ret;
 172     DWORD error;
 173     static CHAR notnull[] = "NotNull";
 174     static const WCHAR machine[] = { 'd','u','m','m','y',0 };
 175     static const WCHAR empty[] = { 0 };
 176
 177     SetLastError(0xdeadbeef);
 178     /* create empty DeviceInfoList, but set Reserved to a value, which is not NULL */
 179     devlist = pSetupDiCreateDeviceInfoListExW(NULL, NULL, NULL, notnull);
 180
 181     error = GetLastError();
 182     if (error == ERROR_CALL_NOT_IMPLEMENTED)
 183     {
 184         win_skip("SetupDiCreateDeviceInfoListExW is not implemented\n");
 185         return;
 186     }
 187     ok(devlist == INVALID_HANDLE_VALUE, "SetupDiCreateDeviceInfoListExW failed : %p %d (expected %p)\n", devlist, error, INVALID_HANDLE_VALUE);
 188     ok(error == ERROR_INVALID_PARAMETER, "GetLastError returned wrong value : %d, (expected %d)\n", error, ERROR_INVALID_PARAMETER);
 189
 190     SetLastError(0xdeadbeef);
 191     /* create empty DeviceInfoList, but set MachineName to something */
 192     devlist = pSetupDiCreateDeviceInfoListExW(NULL, NULL, machine, NULL);
 193
 194     error = GetLastError();
 195     if (error == ERROR_CALL_NOT_IMPLEMENTED)
 196     {
 197         /* win10 reports ERROR_CALL_NOT_IMPLEMENTED at first here */
 198         win_skip("SetupDiCreateDeviceInfoListExW is not implemented\n");
 199         return;
 200     }
 201     ok(devlist == INVALID_HANDLE_VALUE, "SetupDiCreateDeviceInfoListExW failed : %p %d (expected %p)\n", devlist, error, INVALID_HANDLE_VALUE);
 202     ok(error == ERROR_INVALID_MACHINENAME || error == ERROR_MACHINE_UNAVAILABLE, "GetLastError returned wrong value : %d, (expected %d or %d)\n", error, ERROR_INVALID_MACHINENAME, ERROR_MACHINE_UNAVAILABLE);
 203
 204     /* create empty DeviceInfoList */
 205     devlist = pSetupDiCreateDeviceInfoListExW(NULL, NULL, NULL, NULL);
 206     ok(devlist && devlist != INVALID_HANDLE_VALUE, "SetupDiCreateDeviceInfoListExW failed : %p %d (expected != %p)\n", devlist, error, INVALID_HANDLE_VALUE);
 207
 208     /* destroy DeviceInfoList */
 209     ret = pSetupDiDestroyDeviceInfoList(devlist);
 210     ok(ret, "SetupDiDestroyDeviceInfoList failed : %d\n", error);
 211
 212     /* create empty DeviceInfoList with empty machine name */
 213     devlist = pSetupDiCreateDeviceInfoListExW(NULL, NULL, empty, NULL);
 214     ok(devlist && devlist != INVALID_HANDLE_VALUE, "SetupDiCreateDeviceInfoListExW failed : %p %d (expected != %p)\n", devlist, error, INVALID_HANDLE_VALUE);
 215
 216     /* destroy DeviceInfoList */
 217     ret = pSetupDiDestroyDeviceInfoList(devlist);
 218     ok(ret, "SetupDiDestroyDeviceInfoList failed : %d\n", error);
 219 }
 220
 221 static void test_SetupDiOpenClassRegKeyExA(void)
 222 {
 223     static const CHAR guidString[] = "{6a55b5a4-3f65-11db-b704-0011955c2bdb}";
 224     HKEY hkey;
 225
 226     /* Check return value for nonexistent key */
 227     hkey = pSetupDiOpenClassRegKeyExA(&guid, KEY_ALL_ACCESS,
 228         DIOCR_INSTALLER, NULL, NULL);
 229     ok(hkey == INVALID_HANDLE_VALUE,
 230         "returned %p (expected INVALID_HANDLE_VALUE)\n", hkey);
 231
 232     /* Test it for a key that exists */
 233     hkey = SetupDiOpenClassRegKey(NULL, KEY_ALL_ACCESS);
 234     if (hkey != INVALID_HANDLE_VALUE)
 235     {
 236         HKEY classKey;
 237         if (RegCreateKeyA(hkey, guidString, &classKey) == ERROR_SUCCESS)
 238         {
 239             RegCloseKey(classKey);
 240             SetLastError(0xdeadbeef);
 241             classKey = pSetupDiOpenClassRegKeyExA(&guid, KEY_ALL_ACCESS,
 242                 DIOCR_INSTALLER, NULL, NULL);
 243             ok(classKey != INVALID_HANDLE_VALUE,
 244                 "opening class registry key failed with error %d\n",
 245                 GetLastError());
 246             if (classKey != INVALID_HANDLE_VALUE)
 247                 RegCloseKey(classKey);
 248             RegDeleteKeyA(hkey, guidString);
 249         }
 250         else
 251             trace("failed to create registry key for test\n");
 252
 253         RegCloseKey(hkey);
 254     }
 255     else
 256         trace("failed to open classes key %u\n", GetLastError());
 257 }
 258
 259 static void create_inf_file(LPCSTR filename)
 260 {
 261     DWORD dwNumberOfBytesWritten;
 262     HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
 263                             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 264
 265     static const char data[] =
 266         "[Version]\n"
 267         "Signature=\"$Chicago$\"\n"
 268         "Class=Bogus\n"
 269         "ClassGUID={6a55b5a4-3f65-11db-b704-0011955c2bdb}\n"
 270         "[ClassInstall32]\n"
 271         "AddReg=BogusClass.NT.AddReg\n"
 272         "[BogusClass.NT.AddReg]\n"
 273         "HKR,,,,\"Wine test devices\"\n";
 274
 275     WriteFile(hf, data, sizeof(data) - 1, &dwNumberOfBytesWritten, NULL);
 276     CloseHandle(hf);
 277 }
 278
 279 static void get_temp_filename(LPSTR path)
 280 {
 281     static char curr[MAX_PATH] = { 0 };
 282     char temp[MAX_PATH];
 283     LPSTR ptr;
 284
 285     if (!*curr)
 286         GetCurrentDirectoryA(MAX_PATH, curr);
 287     GetTempFileNameA(curr, "set", 0, temp);
 288     ptr = strrchr(temp, '\\');
 289
 290     lstrcpyA(path, ptr + 1);
 291 }
 292
 293 static void testInstallClass(void)
 294 {
 295     static const WCHAR classKey[] = {'S','y','s','t','e','m','\\',
 296      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 297      'C','o','n','t','r','o','l','\\','C','l','a','s','s','\\',
 298      '{','6','a','5','5','b','5','a','4','-','3','f','6','5','-',
 299      '1','1','d','b','-','b','7','0','4','-',
 300      '0','0','1','1','9','5','5','c','2','b','d','b','}',0};
 301     char tmpfile[MAX_PATH];
 302     BOOL ret;
 303
 304     tmpfile[0] = '.';
 305     tmpfile[1] = '\\';
 306     get_temp_filename(tmpfile + 2);
 307     create_inf_file(tmpfile + 2);
 308
 309     ret = pSetupDiInstallClassA(NULL, NULL, 0, NULL);
 310     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 311      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 312     ret = pSetupDiInstallClassA(NULL, NULL, DI_NOVCP, NULL);
 313     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 314      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 315     ret = pSetupDiInstallClassA(NULL, tmpfile + 2, DI_NOVCP, NULL);
 316     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 317      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 318     ret = pSetupDiInstallClassA(NULL, tmpfile + 2, 0, NULL);
 319     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
 320      "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
 321     /* The next call will succeed. Information is put into the registry but the
 322      * location(s) is/are depending on the Windows version.
 323      */
 324     ret = pSetupDiInstallClassA(NULL, tmpfile, 0, NULL);
 325     ok(ret, "SetupDiInstallClassA failed: %08x\n", GetLastError());
 326
 327     ok(!RegDeleteKeyW(HKEY_LOCAL_MACHINE, classKey),
 328      "Couldn't delete classkey\n");
 329
 330     DeleteFileA(tmpfile);
 331 }
 332
 333 static void testCreateDeviceInfo(void)
 334 {
 335     BOOL ret;
 336     HDEVINFO set;
 337
 338     SetLastError(0xdeadbeef);
 339     ret = pSetupDiCreateDeviceInfoA(NULL, NULL, NULL, NULL, NULL, 0, NULL);
 340     ok(!ret, "Expected failure\n");
 341     ok(GetLastError() == ERROR_INVALID_DEVINST_NAME ||
 342       GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 343      "Unexpected last error, got %08x\n", GetLastError());
 344
 345     SetLastError(0xdeadbeef);
 346     ret = pSetupDiCreateDeviceInfoA(NULL, "Root\\LEGACY_BOGUS\\0000", NULL,
 347      NULL, NULL, 0, NULL);
 348     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 349      "Expected ERROR_INVALID_HANDLEHANDLE, got %08x\n", GetLastError());
 350     set = pSetupDiCreateDeviceInfoList(&guid, NULL);
 351     ok(set != NULL, "SetupDiCreateDeviceInfoList failed: %08x\n",
 352      GetLastError());
 353     if (set)
 354     {
 355         SP_DEVINFO_DATA devInfo = { 0 };
 356         DWORD i;
 357         static GUID deadbeef =
 358          {0xdeadbeef, 0xdead, 0xbeef, {0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef}};
 359
 360         /* No GUID given */
 361         SetLastError(0xdeadbeef);
 362         ret = pSetupDiCreateDeviceInfoA(set, "Root\\LEGACY_BOGUS\\0000", NULL,
 363          NULL, NULL, 0, NULL);
 364         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 365             "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 366
 367         /* We can't add device information to the set with a different GUID */
 368         SetLastError(0xdeadbeef);
 369         ret = pSetupDiCreateDeviceInfoA(set, "Root\\LEGACY_BOGUS\\0000",
 370          &deadbeef, NULL, NULL, 0, NULL);
 371         ok(!ret && GetLastError() == ERROR_CLASS_MISMATCH,
 372          "Expected ERROR_CLASS_MISMATCH, got %08x\n", GetLastError());
 373
 374         /* Finally, with all three required parameters, this succeeds: */
 375         ret = pSetupDiCreateDeviceInfoA(set, "Root\\LEGACY_BOGUS\\0000", &guid,
 376          NULL, NULL, 0, NULL);
 377         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 378         /* This fails because the device ID already exists.. */
 379         SetLastError(0xdeadbeef);
 380         ret = pSetupDiCreateDeviceInfoA(set, "Root\\LEGACY_BOGUS\\0000", &guid,
 381          NULL, NULL, 0, &devInfo);
 382         ok(!ret && GetLastError() == ERROR_DEVINST_ALREADY_EXISTS,
 383          "Expected ERROR_DEVINST_ALREADY_EXISTS, got %08x\n", GetLastError());
 384         /* whereas this "fails" because cbSize is wrong.. */
 385         SetLastError(0xdeadbeef);
 386         ret = pSetupDiCreateDeviceInfoA(set, "LEGACY_BOGUS", &guid, NULL, NULL,
 387          DICD_GENERATE_ID, &devInfo);
 388         ok(!ret && GetLastError() == ERROR_INVALID_USER_BUFFER,
 389          "Expected ERROR_INVALID_USER_BUFFER, got %08x\n", GetLastError());
 390         /* and this finally succeeds. */
 391         devInfo.cbSize = sizeof(devInfo);
 392         ret = pSetupDiCreateDeviceInfoA(set, "LEGACY_BOGUS", &guid, NULL, NULL,
 393          DICD_GENERATE_ID, &devInfo);
 394         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 395         /* There were three devices added, however - the second failure just
 396          * resulted in the SP_DEVINFO_DATA not getting copied.
 397          */
 398         SetLastError(0xdeadbeef);
 399         i = 0;
 400         while (pSetupDiEnumDeviceInfo(set, i, &devInfo))
 401             i++;
 402         ok(i == 3, "Expected 3 devices, got %d\n", i);
 403         ok(GetLastError() == ERROR_NO_MORE_ITEMS,
 404          "SetupDiEnumDeviceInfo failed: %08x\n", GetLastError());
 405
 406         ret = pSetupDiRemoveDevice(set, &devInfo);
 407         todo_wine ok(ret, "got %u\n", GetLastError());
 408         pSetupDiDestroyDeviceInfoList(set);
 409     }
 410 }
 411
 412 static void testGetDeviceInstanceId(void)
 413 {
 414     BOOL ret;
 415     HDEVINFO set;
 416     SP_DEVINFO_DATA devInfo = { 0 };
 417
 418     SetLastError(0xdeadbeef);
 419     ret = pSetupDiGetDeviceInstanceIdA(NULL, NULL, NULL, 0, NULL);
 420     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 421      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
 422     SetLastError(0xdeadbeef);
 423     ret = pSetupDiGetDeviceInstanceIdA(NULL, &devInfo, NULL, 0, NULL);
 424     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 425      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
 426     set = pSetupDiCreateDeviceInfoList(&guid, NULL);
 427     ok(set != NULL, "SetupDiCreateDeviceInfoList failed: %08x\n",
 428      GetLastError());
 429     if (set)
 430     {
 431         char instanceID[MAX_PATH];
 432         DWORD size;
 433
 434         SetLastError(0xdeadbeef);
 435         ret = pSetupDiGetDeviceInstanceIdA(set, NULL, NULL, 0, NULL);
 436         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 437          "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 438         SetLastError(0xdeadbeef);
 439         ret = pSetupDiGetDeviceInstanceIdA(set, &devInfo, NULL, 0, NULL);
 440         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 441          "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 442         SetLastError(0xdeadbeef);
 443         ret = pSetupDiGetDeviceInstanceIdA(set, &devInfo, NULL, 0, &size);
 444         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 445          "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 446         devInfo.cbSize = sizeof(devInfo);
 447         SetLastError(0xdeadbeef);
 448         ret = pSetupDiGetDeviceInstanceIdA(set, &devInfo, NULL, 0, &size);
 449         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 450          "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
 451         ret = pSetupDiCreateDeviceInfoA(set, "Root\\LEGACY_BOGUS\\0000", &guid,
 452          NULL, NULL, 0, &devInfo);
 453         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 454         SetLastError(0xdeadbeef);
 455         ret = pSetupDiGetDeviceInstanceIdA(set, &devInfo, NULL, 0, &size);
 456         ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 457          "Expected ERROR_INSUFFICIENT_BUFFER, got %08x\n", GetLastError());
 458         ret = pSetupDiGetDeviceInstanceIdA(set, &devInfo, instanceID,
 459          sizeof(instanceID), NULL);
 460         ok(ret, "SetupDiGetDeviceInstanceIdA failed: %08x\n", GetLastError());
 461         ok(!lstrcmpA(instanceID, "ROOT\\LEGACY_BOGUS\\0000"),
 462          "Unexpected instance ID %s\n", instanceID);
 463         ret = pSetupDiCreateDeviceInfoA(set, "LEGACY_BOGUS", &guid,
 464          NULL, NULL, DICD_GENERATE_ID, &devInfo);
 465         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 466         ret = pSetupDiGetDeviceInstanceIdA(set, &devInfo, instanceID,
 467          sizeof(instanceID), NULL);
 468         ok(ret, "SetupDiGetDeviceInstanceIdA failed: %08x\n", GetLastError());
 469         /* NT4 returns 'Root' and W2K and above 'ROOT' */
 470         ok(!lstrcmpiA(instanceID, "ROOT\\LEGACY_BOGUS\\0001"),
 471          "Unexpected instance ID %s\n", instanceID);
 472
 473         ret = pSetupDiRemoveDevice(set, &devInfo);
 474         todo_wine ok(ret, "got %u\n", GetLastError());
 475         pSetupDiDestroyDeviceInfoList(set);
 476     }
 477 }
 478
 479 static void testRegisterDeviceInfo(void)
 480 {
 481     static const WCHAR bogus[] = {'S','y','s','t','e','m','\\',
 482      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 483      'E','n','u','m','\\','U','S','B','\\','B','O','G','U','S',0};
 484     BOOL ret;
 485     HDEVINFO set;
 486
 487     SetLastError(0xdeadbeef);
 488     ret = pSetupDiRegisterDeviceInfo(NULL, NULL, 0, NULL, NULL, NULL);
 489     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 490      "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 491     set = pSetupDiCreateDeviceInfoList(&guid, NULL);
 492     ok(set != NULL, "SetupDiCreateDeviceInfoList failed: %d\n", GetLastError());
 493     if (set)
 494     {
 495         SP_DEVINFO_DATA devInfo = { 0 };
 496
 497         SetLastError(0xdeadbeef);
 498         ret = pSetupDiRegisterDeviceInfo(set, NULL, 0, NULL, NULL, NULL);
 499         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 500          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 501         SetLastError(0xdeadbeef);
 502         ret = pSetupDiRegisterDeviceInfo(set, &devInfo, 0, NULL, NULL, NULL);
 503         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 504          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 505         devInfo.cbSize = sizeof(devInfo);
 506         SetLastError(0xdeadbeef);
 507         ret = pSetupDiRegisterDeviceInfo(set, &devInfo, 0, NULL, NULL, NULL);
 508         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 509          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 510
 511         ret = pSetupDiCreateDeviceInfoA(set, "USB\\BOGUS\\0000", &guid,
 512          NULL, NULL, 0, &devInfo);
 513         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 514
 515         ret = pSetupDiRegisterDeviceInfo(set, &devInfo, 0, NULL, NULL, NULL);
 516         ok(ret, "SetupDiRegisterDeviceInfo failed: %d\n", GetLastError());
 517
 518         ret = pSetupDiRemoveDevice(set, &devInfo);
 519         todo_wine ok(ret, "got %u\n", GetLastError());
 520         pSetupDiDestroyDeviceInfoList(set);
 521
 522         /* remove once Wine is fixed */
 523         devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, bogus);
 524     }
 525 }
 526
 527 static void testCreateDeviceInterface(void)
 528 {
 529     BOOL ret;
 530     HDEVINFO set;
 531
 532     if (!pSetupDiCreateDeviceInterfaceA || !pSetupDiEnumDeviceInterfaces)
 533     {
 534         win_skip("SetupDiCreateDeviceInterfaceA and/or SetupDiEnumDeviceInterfaces are not available\n");
 535         return;
 536     }
 537     SetLastError(0xdeadbeef);
 538     ret = pSetupDiCreateDeviceInterfaceA(NULL, NULL, NULL, NULL, 0, NULL);
 539     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 540      "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 541     SetLastError(0xdeadbeef);
 542     ret = pSetupDiCreateDeviceInterfaceA(NULL, NULL, &guid, NULL, 0, NULL);
 543     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 544      "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 545     set = pSetupDiCreateDeviceInfoList(&guid, NULL);
 546     ok(set != NULL, "SetupDiCreateDeviceInfoList failed: %d\n", GetLastError());
 547     if (set)
 548     {
 549         SP_DEVINFO_DATA devInfo = { 0 };
 550         SP_DEVICE_INTERFACE_DATA interfaceData = { sizeof(interfaceData),
 551             { 0 } };
 552         DWORD i;
 553
 554         SetLastError(0xdeadbeef);
 555         ret = pSetupDiCreateDeviceInterfaceA(set, NULL, NULL, NULL, 0, NULL);
 556         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 557          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 558         SetLastError(0xdeadbeef);
 559         ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, NULL, NULL, 0,
 560                 NULL);
 561         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 562          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 563         devInfo.cbSize = sizeof(devInfo);
 564         ret = pSetupDiCreateDeviceInfoA(set, "ROOT\\LEGACY_BOGUS\\0000", &guid,
 565                 NULL, NULL, 0, &devInfo);
 566         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 567         SetLastError(0xdeadbeef);
 568         ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, NULL, NULL, 0,
 569                 NULL);
 570         ok(!ret && GetLastError() == ERROR_INVALID_USER_BUFFER,
 571          "Expected ERROR_INVALID_USER_BUFFER, got %08x\n", GetLastError());
 572         ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, &guid, NULL, 0,
 573                 NULL);
 574         ok(ret, "SetupDiCreateDeviceInterfaceA failed: %08x\n", GetLastError());
 575         /* Creating the same interface a second time succeeds */
 576         ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, &guid, NULL, 0,
 577                 NULL);
 578         ok(ret, "SetupDiCreateDeviceInterfaceA failed: %08x\n", GetLastError());
 579         ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, &guid, "Oogah", 0,
 580                 NULL);
 581         ok(ret, "SetupDiCreateDeviceInterfaceA failed: %08x\n", GetLastError());
 582         ret = pSetupDiEnumDeviceInterfaces(set, &devInfo, &guid, 0,
 583                 &interfaceData);
 584         ok(ret, "SetupDiEnumDeviceInterfaces failed: %d\n", GetLastError());
 585         i = 0;
 586         while (pSetupDiEnumDeviceInterfaces(set, &devInfo, &guid, i,
 587                     &interfaceData))
 588             i++;
 589         ok(i == 2, "expected 2 interfaces, got %d\n", i);
 590         ok(GetLastError() == ERROR_NO_MORE_ITEMS,
 591          "SetupDiEnumDeviceInterfaces failed: %08x\n", GetLastError());
 592
 593         for (i = 0; i < 2; i++)
 594         {
 595             ret = pSetupDiEnumDeviceInterfaces(set, &devInfo, &guid, i, &interfaceData);
 596             ok(ret, "SetupDiEnumDeviceInterfaces failed: %08x\n", GetLastError());
 597
 598             ret = pSetupDiRemoveDeviceInterface(set, &interfaceData);
 599             todo_wine ok(ret, "SetupDiRemoveDeviceInterface failed: %08x\n", GetLastError());
 600         }
 601
 602         ret = pSetupDiRemoveDevice(set, &devInfo);
 603         todo_wine ok(ret, "got %u\n", GetLastError());
 604
 605         ret = pSetupDiDestroyDeviceInfoList(set);
 606         ok(ret, "SetupDiDestroyDeviceInfoList failed: %08x\n", GetLastError());
 607     }
 608 }
 609
 610 static void testGetDeviceInterfaceDetail(void)
 611 {
 612     static const WCHAR bogus[] = {'S','y','s','t','e','m','\\',
 613      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 614      'E','n','u','m','\\','R','o','o','t','\\',
 615      'L','E','G','A','C','Y','_','B','O','G','U','S',0};
 616     static const WCHAR devclass[] = {'S','y','s','t','e','m','\\',
 617      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 618      'C','o','n','t','r','o','l','\\','D','e','v','i','c','e','C','l','a','s','s','e','s','\\',
 619      '{','6','a','5','5','b','5','a','4','-','3','f','6','5','-',
 620      '1','1','d','b','-','b','7','0','4','-',
 621      '0','0','1','1','9','5','5','c','2','b','d','b','}',0};
 622     BOOL ret;
 623     HDEVINFO set;
 624
 625     if (!pSetupDiCreateDeviceInterfaceA || !pSetupDiGetDeviceInterfaceDetailA)
 626     {
 627         win_skip("SetupDiCreateDeviceInterfaceA and/or SetupDiGetDeviceInterfaceDetailA are not available\n");
 628         return;
 629     }
 630     SetLastError(0xdeadbeef);
 631     ret = pSetupDiGetDeviceInterfaceDetailA(NULL, NULL, NULL, 0, NULL, NULL);
 632     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 633      "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 634     set = pSetupDiCreateDeviceInfoList(&guid, NULL);
 635     ok(set != NULL, "SetupDiCreateDeviceInfoList failed: %d\n", GetLastError());
 636     if (set)
 637     {
 638         SP_DEVINFO_DATA devInfo = { sizeof(devInfo), { 0 } };
 639         SP_DEVICE_INTERFACE_DATA interfaceData = { sizeof(interfaceData),
 640             { 0 } };
 641         DWORD size = 0;
 642
 643         SetLastError(0xdeadbeef);
 644         ret = pSetupDiGetDeviceInterfaceDetailA(set, NULL, NULL, 0, NULL,
 645                 NULL);
 646         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 647          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 648         ret = pSetupDiCreateDeviceInfoA(set, "ROOT\\LEGACY_BOGUS\\0000", &guid,
 649                 NULL, NULL, 0, &devInfo);
 650         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 651         SetLastError(0xdeadbeef);
 652         ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, &guid, NULL, 0,
 653                 &interfaceData);
 654         ok(ret, "SetupDiCreateDeviceInterfaceA failed: %08x\n", GetLastError());
 655         SetLastError(0xdeadbeef);
 656         ret = pSetupDiGetDeviceInterfaceDetailA(set, &interfaceData, NULL,
 657                 0, NULL, NULL);
 658         ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 659          "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 660         SetLastError(0xdeadbeef);
 661         ret = pSetupDiGetDeviceInterfaceDetailA(set, &interfaceData, NULL,
 662                 100, NULL, NULL);
 663         ok(!ret && GetLastError() == ERROR_INVALID_USER_BUFFER,
 664          "Expected ERROR_INVALID_USER_BUFFER, got %08x\n", GetLastError());
 665         SetLastError(0xdeadbeef);
 666         ret = pSetupDiGetDeviceInterfaceDetailA(set, &interfaceData, NULL,
 667                 0, &size, NULL);
 668         ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 669          "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 670         if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 671         {
 672             static const char path[] =
 673              "\\\\?\\root#legacy_bogus#0000#{6a55b5a4-3f65-11db-b704-0011955c2bdb}";
 674             static const char path_w2k[] =
 675              "\\\\?\\root#legacy_bogus#0000#{6a55b5a4-3f65-11db-b704-0011955c2bdb}\\";
 676             SP_DEVINFO_DATA devinfo;
 677             LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, size);
 678             SP_DEVICE_INTERFACE_DETAIL_DATA_A *detail =
 679                 (SP_DEVICE_INTERFACE_DETAIL_DATA_A *)buf;
 680             DWORD expectedsize = FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath) + sizeof(WCHAR)*(1 + strlen(path));
 681
 682             detail->cbSize = 0;
 683             SetLastError(0xdeadbeef);
 684             ret = pSetupDiGetDeviceInterfaceDetailA(set, &interfaceData, detail,
 685                     size, &size, NULL);
 686             ok(!ret && GetLastError() == ERROR_INVALID_USER_BUFFER,
 687              "Expected ERROR_INVALID_USER_BUFFER, got %08x\n", GetLastError());
 688             detail->cbSize = size;
 689             SetLastError(0xdeadbeef);
 690             ret = pSetupDiGetDeviceInterfaceDetailA(set, &interfaceData, detail,
 691                     size, &size, NULL);
 692             ok(!ret && GetLastError() == ERROR_INVALID_USER_BUFFER,
 693              "Expected ERROR_INVALID_USER_BUFFER, got %08x\n", GetLastError());
 694             detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
 695             SetLastError(0xdeadbeef);
 696             ret = pSetupDiGetDeviceInterfaceDetailA(set, &interfaceData, detail,
 697                     size, &size, NULL);
 698             ok(ret, "SetupDiGetDeviceInterfaceDetailA failed: %d\n",
 699                     GetLastError());
 700             ok(!lstrcmpiA(path, detail->DevicePath) ||
 701              !lstrcmpiA(path_w2k, detail->DevicePath), "Unexpected path %s\n",
 702              detail->DevicePath);
 703             /* Check SetupDiGetDeviceInterfaceDetailW */
 704             memset(&devinfo, 0, sizeof(devinfo));
 705             devinfo.cbSize = sizeof(devinfo);
 706             ret = pSetupDiGetDeviceInterfaceDetailW(set, &interfaceData, NULL, 0, &size, &devinfo);
 707             ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 708              "Expected ERROR_INSUFFICIENT_BUFFER, got error code: %d\n", GetLastError());
 709             ok(devinfo.DevInst, "Expected DevInst to be set\n");
 710             ok(expectedsize == size ||
 711              (expectedsize + sizeof(WCHAR)) == size /* W2K adds a backslash */,
 712              "SetupDiGetDeviceInterfaceDetailW returned wrong reqsize, got %d\n",
 713              size);
 714
 715             HeapFree(GetProcessHeap(), 0, buf);
 716         }
 717
 718         ret = pSetupDiEnumDeviceInterfaces(set, &devInfo, &guid, 0, &interfaceData);
 719         ok(ret, "SetupDiEnumDeviceInterfaces failed: %08x\n", GetLastError());
 720
 721         ret = pSetupDiRemoveDeviceInterface(set, &interfaceData);
 722         todo_wine ok(ret, "SetupDiRemoveDeviceInterface failed: %08x\n", GetLastError());
 723
 724         ret = pSetupDiRemoveDevice(set, &devInfo);
 725         todo_wine ok(ret, "got %u\n", GetLastError());
 726         pSetupDiDestroyDeviceInfoList(set);
 727
 728         /* remove once Wine is fixed */
 729         devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, bogus);
 730         devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, devclass);
 731     }
 732 }
 733
 734 static void testDevRegKey(void)
 735 {
 736     static const WCHAR classKey[] = {'S','y','s','t','e','m','\\',
 737      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 738      'C','o','n','t','r','o','l','\\','C','l','a','s','s','\\',
 739      '{','6','a','5','5','b','5','a','4','-','3','f','6','5','-',
 740      '1','1','d','b','-','b','7','0','4','-',
 741      '0','0','1','1','9','5','5','c','2','b','d','b','}',0};
 742     static const WCHAR bogus[] = {'S','y','s','t','e','m','\\',
 743      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 744      'E','n','u','m','\\','R','o','o','t','\\',
 745      'L','E','G','A','C','Y','_','B','O','G','U','S',0};
 746     BOOL ret;
 747     HDEVINFO set;
 748     HKEY key = NULL;
 749
 750     SetLastError(0xdeadbeef);
 751     key = pSetupDiCreateDevRegKeyW(NULL, NULL, 0, 0, 0, NULL, NULL);
 752     ok(key == INVALID_HANDLE_VALUE,
 753      "Expected INVALID_HANDLE_VALUE, got %p\n", key);
 754     ok(GetLastError() == ERROR_INVALID_HANDLE,
 755      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
 756
 757     set = pSetupDiCreateDeviceInfoList(&guid, NULL);
 758     ok(set != NULL, "SetupDiCreateDeviceInfoList failed: %d\n", GetLastError());
 759     if (set)
 760     {
 761         SP_DEVINFO_DATA devInfo = { sizeof(devInfo), { 0 } };
 762         LONG res;
 763
 764         /* The device info key shouldn't be there */
 765         res = RegOpenKeyW(HKEY_LOCAL_MACHINE, bogus, &key);
 766         ok(res != ERROR_SUCCESS, "Expected key to not exist\n");
 767         RegCloseKey(key);
 768         /* Create the device information */
 769         ret = pSetupDiCreateDeviceInfoA(set, "ROOT\\LEGACY_BOGUS\\0000", &guid,
 770                 NULL, NULL, 0, &devInfo);
 771         ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 772         /* The device info key should have been created */
 773         ok(!RegOpenKeyW(HKEY_LOCAL_MACHINE, bogus, &key),
 774          "Expected registry key to exist\n");
 775         RegCloseKey(key);
 776         SetLastError(0xdeadbeef);
 777         key = pSetupDiOpenDevRegKey(NULL, NULL, 0, 0, 0, 0);
 778         ok(!key || key == INVALID_HANDLE_VALUE,
 779          "Expected INVALID_HANDLE_VALUE or a NULL key (NT4)\n");
 780         ok(GetLastError() == ERROR_INVALID_HANDLE,
 781          "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 782         SetLastError(0xdeadbeef);
 783         key = pSetupDiOpenDevRegKey(set, NULL, 0, 0, 0, 0);
 784         ok(key == INVALID_HANDLE_VALUE &&
 785          GetLastError() == ERROR_INVALID_PARAMETER,
 786          "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 787         SetLastError(0xdeadbeef);
 788         key = pSetupDiOpenDevRegKey(set, &devInfo, 0, 0, 0, 0);
 789         ok(key == INVALID_HANDLE_VALUE &&
 790          GetLastError() == ERROR_INVALID_FLAGS,
 791          "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 792         SetLastError(0xdeadbeef);
 793         key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0, 0, 0);
 794         ok(key == INVALID_HANDLE_VALUE &&
 795          GetLastError() == ERROR_INVALID_FLAGS,
 796          "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 797         SetLastError(0xdeadbeef);
 798         key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 799          DIREG_BOTH, 0);
 800         ok(key == INVALID_HANDLE_VALUE &&
 801          GetLastError() == ERROR_INVALID_FLAGS,
 802          "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 803         SetLastError(0xdeadbeef);
 804         key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 805          DIREG_DRV, 0);
 806         ok(key == INVALID_HANDLE_VALUE &&
 807          GetLastError() == ERROR_DEVINFO_NOT_REGISTERED,
 808          "Expected ERROR_DEVINFO_NOT_REGISTERED, got %08x\n", GetLastError());
 809         SetLastError(0xdeadbeef);
 810         ret = pSetupDiRegisterDeviceInfo(set, &devInfo, 0, NULL, NULL, NULL);
 811         ok(ret, "SetupDiRegisterDeviceInfo failed: %08x\n", GetLastError());
 812         SetLastError(0xdeadbeef);
 813         key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 814          DIREG_DRV, 0);
 815         /* The software key isn't created by default */
 816         ok(key == INVALID_HANDLE_VALUE &&
 817          GetLastError() == ERROR_KEY_DOES_NOT_EXIST,
 818          "Expected ERROR_KEY_DOES_NOT_EXIST, got %08x\n", GetLastError());
 819         SetLastError(0xdeadbeef);
 820         key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 821          DIREG_DEV, 0);
 822         todo_wine
 823         ok(key == INVALID_HANDLE_VALUE &&
 824          GetLastError() == ERROR_KEY_DOES_NOT_EXIST,
 825          "Expected ERROR_KEY_DOES_NOT_EXIST, got %08x\n", GetLastError());
 826         SetLastError(0xdeadbeef);
 827         /* The class key shouldn't be there */
 828         res = RegOpenKeyW(HKEY_LOCAL_MACHINE, classKey, &key);
 829         todo_wine
 830         ok(res != ERROR_SUCCESS, "Expected key to not exist\n");
 831         RegCloseKey(key);
 832         /* Create the device reg key */
 833         key = pSetupDiCreateDevRegKeyW(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 834          DIREG_DRV, NULL, NULL);
 835         /* Vista and higher don't actually create the key */
 836         ok(key != INVALID_HANDLE_VALUE || GetLastError() == ERROR_KEY_DOES_NOT_EXIST,
 837          "SetupDiCreateDevRegKey failed: %08x\n", GetLastError());
 838         if (key != INVALID_HANDLE_VALUE)
 839         {
 840             RegCloseKey(key);
 841             /* The class key should have been created */
 842             ok(!RegOpenKeyW(HKEY_LOCAL_MACHINE, classKey, &key),
 843              "Expected registry key to exist\n");
 844             RegCloseKey(key);
 845             SetLastError(0xdeadbeef);
 846             key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 847              DIREG_DRV, 0);
 848             todo_wine
 849             ok(key == INVALID_HANDLE_VALUE &&
 850              (GetLastError() == ERROR_INVALID_DATA ||
 851              GetLastError() == ERROR_ACCESS_DENIED), /* win2k3 */
 852              "Expected ERROR_INVALID_DATA or ERROR_ACCESS_DENIED, got %08x\n", GetLastError());
 853             key = pSetupDiOpenDevRegKey(set, &devInfo, DICS_FLAG_GLOBAL, 0,
 854              DIREG_DRV, KEY_READ);
 855             ok(key != INVALID_HANDLE_VALUE, "SetupDiOpenDevRegKey failed: %08x\n",
 856              GetLastError());
 857             RegCloseKey(key);
 858         }
 859
 860         ret = pSetupDiRemoveDevice(set, &devInfo);
 861         todo_wine ok(ret, "got %u\n", GetLastError());
 862         pSetupDiDestroyDeviceInfoList(set);
 863
 864         /* remove once Wine is fixed */
 865         devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, bogus);
 866         devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, classKey);
 867     }
 868 }
 869
 870 static void testRegisterAndGetDetail(void)
 871 {
 872     static const WCHAR classKey[] = {'S','y','s','t','e','m','\\',
 873      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 874      'C','o','n','t','r','o','l','\\','C','l','a','s','s','\\',
 875      '{','6','a','5','5','b','5','a','4','-','3','f','6','5','-',
 876      '1','1','d','b','-','b','7','0','4','-',
 877      '0','0','1','1','9','5','5','c','2','b','d','b','}',0};
 878     static const WCHAR bogus[] = {'S','y','s','t','e','m','\\',
 879      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 880      'E','n','u','m','\\','R','o','o','t','\\',
 881      'L','E','G','A','C','Y','_','B','O','G','U','S',0};
 882     HDEVINFO set, set2;
 883     BOOL ret;
 884     SP_DEVINFO_DATA devInfo = { sizeof(SP_DEVINFO_DATA), { 0 } };
 885     SP_DEVICE_INTERFACE_DATA interfaceData = { sizeof(interfaceData), { 0 } };
 886     SP_DEVICE_INTERFACE_DATA interfaceData2 = { sizeof(interfaceData2), { 0 } };
 887     DWORD dwSize = 0;
 888     HKEY key;
 889     LONG res;
 890
 891     if (!pSetupDiCreateDeviceInterfaceA || !pSetupDiEnumDeviceInterfaces ||
 892         !pSetupDiGetDeviceInterfaceDetailA)
 893     {
 894         win_skip("Needed functions are not available\n");
 895         return;
 896     }
 897
 898     SetLastError(0xdeadbeef);
 899     set = pSetupDiGetClassDevsA(&guid, NULL, 0, DIGCF_ALLCLASSES);
 900     ok(set != INVALID_HANDLE_VALUE, "SetupDiGetClassDevsA failed: %08x\n",
 901      GetLastError());
 902
 903     res = RegOpenKeyW(HKEY_LOCAL_MACHINE, bogus, &key);
 904     ok(res != ERROR_SUCCESS, "Expected key to not exist\n");
 905     RegCloseKey(key);
 906
 907     SetLastError(0xdeadbeef);
 908     ret = pSetupDiCreateDeviceInfoA(set, "LEGACY_BOGUS", &guid, NULL, 0,
 909      DICD_GENERATE_ID, &devInfo);
 910     ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 911     SetLastError(0xdeadbeef);
 912     ret = pSetupDiCreateDeviceInterfaceA(set, &devInfo, &guid, NULL, 0, &interfaceData);
 913     ok(ret, "SetupDiCreateDeviceInterfaceA failed: %08x\n", GetLastError());
 914     SetLastError(0xdeadbeef);
 915     ret = pSetupDiRegisterDeviceInfo(set, &devInfo, 0, NULL, NULL, NULL);
 916     ok(ret, "SetupDiRegisterDeviceInfo failed: %08x\n", GetLastError());
 917
 918     SetLastError(0xdeadbeef);
 919     set2 = pSetupDiGetClassDevsA(&guid, NULL, 0, DIGCF_DEVICEINTERFACE);
 920     ok(set2 != INVALID_HANDLE_VALUE, "SetupDiGetClassDevsA failed: %08x\n",
 921      GetLastError());
 922
 923     SetLastError(0xdeadbeef);
 924     ret = pSetupDiEnumDeviceInterfaces(set2, NULL, &guid, 0, &interfaceData2);
 925     ok(ret, "SetupDiEnumDeviceInterfaces failed: %08x\n", GetLastError());
 926     SetLastError(0xdeadbeef);
 927     ret = pSetupDiGetDeviceInterfaceDetailA(set2, &interfaceData2, NULL, 0, &dwSize, NULL);
 928     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 929      "Expected ERROR_INSUFFICIENT_BUFFER, got %08x\n", GetLastError());
 930     if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 931     {
 932         static const char path[] =
 933             "\\\\?\\root#legacy_bogus#0000#{6a55b5a4-3f65-11db-b704-0011955c2bdb}";
 934         static const char path_w10[] =
 935             "\\\\?\\root#legacy_bogus#0001#{6a55b5a4-3f65-11db-b704-0011955c2bdb}";
 936         static const char path_w2k[] =
 937             "\\\\?\\root#legacy_bogus#0000#{6a55b5a4-3f65-11db-b704-0011955c2bdb}\\";
 938         PSP_DEVICE_INTERFACE_DETAIL_DATA_A detail = NULL;
 939
 940         detail = HeapAlloc(GetProcessHeap(), 0, dwSize);
 941         if (detail)
 942         {
 943             detail->cbSize = sizeof(*detail);
 944             SetLastError(0xdeadbeef);
 945             ret = pSetupDiGetDeviceInterfaceDetailA(set2, &interfaceData2,
 946              detail, dwSize, &dwSize, NULL);
 947             ok(ret, "SetupDiGetDeviceInterfaceDetailA failed: %08x\n", GetLastError());
 948             ok(!lstrcmpiA(path, detail->DevicePath) ||
 949                !lstrcmpiA(path_w10, detail->DevicePath) ||
 950                !lstrcmpiA(path_w2k, detail->DevicePath),
 951                "Unexpected path %s\n", detail->DevicePath);
 952             HeapFree(GetProcessHeap(), 0, detail);
 953         }
 954     }
 955
 956     ret = pSetupDiRemoveDeviceInterface(set, &interfaceData);
 957     todo_wine ok(ret, "SetupDiRemoveDeviceInterface failed: %08x\n", GetLastError());
 958
 959     ret = pSetupDiRemoveDevice(set, &devInfo);
 960     todo_wine ok(ret, "got %u\n", GetLastError());
 961
 962     pSetupDiDestroyDeviceInfoList(set);
 963     pSetupDiDestroyDeviceInfoList(set2);
 964
 965     /* remove once Wine is fixed */
 966     devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, bogus);
 967     devinst_RegDeleteTreeW(HKEY_LOCAL_MACHINE, classKey);
 968 }
 969
 970 static void testDeviceRegistryPropertyA(void)
 971 {
 972     HDEVINFO set;
 973     SP_DEVINFO_DATA devInfo = { sizeof(SP_DEVINFO_DATA), { 0 } };
 974     CHAR devName[] = "LEGACY_BOGUS";
 975     CHAR friendlyName[] = "Bogus";
 976     CHAR buf[6] = "";
 977     DWORD buflen = 6;
 978     DWORD size;
 979     DWORD regType;
 980     BOOL ret;
 981     LONG res;
 982     HKEY key;
 983     static const CHAR bogus[] =
 984      "System\\CurrentControlSet\\Enum\\Root\\LEGACY_BOGUS";
 985
 986     SetLastError(0xdeadbeef);
 987     set = pSetupDiGetClassDevsA(&guid, NULL, 0, DIGCF_DEVICEINTERFACE);
 988     ok(set != INVALID_HANDLE_VALUE, "SetupDiGetClassDevsA failed: %08x\n",
 989      GetLastError());
 990     SetLastError(0xdeadbeef);
 991     ret = pSetupDiCreateDeviceInfoA(set, devName, &guid, NULL, NULL,
 992      DICD_GENERATE_ID, &devInfo);
 993     ok(ret, "SetupDiCreateDeviceInfoA failed: %08x\n", GetLastError());
 994     SetLastError(0xdeadbeef);
 995     ret = pSetupDiSetDeviceRegistryPropertyA(NULL, NULL, -1, NULL, 0);
 996     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
 997      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
 998     SetLastError(0xdeadbeef);
 999     ret = pSetupDiSetDeviceRegistryPropertyA(set, NULL, -1, NULL, 0);
1000     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
1001      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
1002     SetLastError(0xdeadbeef);
1003     ret = pSetupDiSetDeviceRegistryPropertyA(set, &devInfo, -1, NULL, 0);
1004     todo_wine
1005     ok(!ret && GetLastError() == ERROR_INVALID_REG_PROPERTY,
1006      "Expected ERROR_INVALID_REG_PROPERTY, got %08x\n", GetLastError());
1007     /* GetLastError() returns nonsense in win2k3 */
1008     ret = pSetupDiSetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1009      NULL, 0);
1010     todo_wine
1011     ok(!ret, "Expected failure, got %d\n", ret);
1012     SetLastError(0xdeadbeef);
1013     ret = pSetupDiSetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1014      (PBYTE)friendlyName, buflen);
1015     ok(ret, "SetupDiSetDeviceRegistryPropertyA failed: %08x\n", GetLastError());
1016     SetLastError(0xdeadbeef);
1017     ret = pSetupDiGetDeviceRegistryPropertyA(NULL, NULL, -1, NULL, NULL, 0, NULL);
1018     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
1019      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
1020     SetLastError(0xdeadbeef);
1021     ret = pSetupDiGetDeviceRegistryPropertyA(set, NULL, -1, NULL, NULL, 0, NULL);
1022     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
1023      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
1024     SetLastError(0xdeadbeef);
1025     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, -1, NULL, NULL, 0, NULL);
1026     todo_wine
1027     ok(!ret && GetLastError() == ERROR_INVALID_REG_PROPERTY,
1028      "Expected ERROR_INVALID_REG_PROPERTY, got %08x\n", GetLastError());
1029     /* GetLastError() returns nonsense in win2k3 */
1030     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1031      NULL, NULL, buflen, NULL);
1032     ok(!ret, "Expected failure, got %d\n", ret);
1033     SetLastError(0xdeadbeef);
1034     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1035      NULL, NULL, 0, &size);
1036     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1037      "Expected ERROR_INSUFFICIENT_BUFFER, got %08x\n", GetLastError());
1038     ok(buflen == size, "Unexpected size: %d\n", size);
1039     SetLastError(0xdeadbeef);
1040     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1041      NULL, (PBYTE)buf, buflen, NULL);
1042     ok(ret, "SetupDiGetDeviceRegistryPropertyA failed: %08x\n", GetLastError());
1043     ok(!lstrcmpiA(friendlyName, buf), "Unexpected property\n");
1044     SetLastError(0xdeadbeef);
1045     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1046      &regType, (PBYTE)buf, buflen, NULL);
1047     ok(ret, "SetupDiGetDeviceRegistryPropertyA failed: %08x\n", GetLastError());
1048     ok(!lstrcmpiA(friendlyName, buf), "Unexpected value of property\n");
1049     ok(regType == REG_SZ, "Unexpected type of property: %d\n", regType);
1050     SetLastError(0xdeadbeef);
1051     ret = pSetupDiSetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1052      NULL, 0);
1053     ok(ret, "SetupDiSetDeviceRegistryPropertyA failed: %08x\n", GetLastError());
1054     SetLastError(0xdeadbeef);
1055     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, SPDRP_FRIENDLYNAME,
1056      NULL, (PBYTE)buf, buflen, &size);
1057     todo_wine
1058     ok(!ret && GetLastError() == ERROR_INVALID_DATA,
1059      "Expected ERROR_INVALID_DATA, got %08x\n", GetLastError());
1060     ret = pSetupDiGetDeviceRegistryPropertyA(set, &devInfo, SPDRP_HARDWAREID,
1061      NULL, NULL, 0, &size);
1062     ok(!ret && GetLastError() == ERROR_INVALID_DATA,
1063      "Expected ERROR_INVALID_DATA, got %08x\n", GetLastError());
1064     pSetupDiDestroyDeviceInfoList(set);
1065
1066     res = RegOpenKeyA(HKEY_LOCAL_MACHINE, bogus, &key);
1067     if(!is_wow64)
1068         todo_wine ok(res == ERROR_FILE_NOT_FOUND, "Expected key to not exist\n");
1069     /* FIXME: Remove when Wine is fixed */
1070     if (res == ERROR_SUCCESS)
1071     {
1072         /* Wine doesn't delete the information currently */
1073         RegDeleteKeyA(HKEY_LOCAL_MACHINE, bogus);
1074     }
1075 }
1076
1077 static void testDeviceRegistryPropertyW(void)
1078 {
1079     HDEVINFO set;
1080     SP_DEVINFO_DATA devInfo = { sizeof(SP_DEVINFO_DATA), { 0 } };
1081     WCHAR devName[] = {'L','E','G','A','C','Y','_','B','O','G','U','S',0};
1082     WCHAR friendlyName[] = {'B','o','g','u','s',0};
1083     WCHAR buf[6] = {0};
1084     DWORD buflen = 6 * sizeof(WCHAR);
1085     DWORD size;
1086     DWORD regType;
1087     BOOL ret;
1088     LONG res;
1089     HKEY key;
1090     static const WCHAR bogus[] = {'S','y','s','t','e','m','\\',
1091      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1092      'E','n','u','m','\\','R','o','o','t','\\',
1093      'L','E','G','A','C','Y','_','B','O','G','U','S',0};
1094
1095     SetLastError(0xdeadbeef);
1096     set = pSetupDiGetClassDevsW(&guid, NULL, 0, DIGCF_DEVICEINTERFACE);
1097     ok(set != INVALID_HANDLE_VALUE, "SetupDiGetClassDevsW failed: %08x\n",
1098      GetLastError());
1099     SetLastError(0xdeadbeef);
1100     ret = pSetupDiCreateDeviceInfoW(set, devName, &guid, NULL, NULL,
1101      DICD_GENERATE_ID, &devInfo);
1102     ok(ret, "SetupDiCreateDeviceInfoW failed: %08x\n", GetLastError());
1103     SetLastError(0xdeadbeef);
1104     ret = pSetupDiSetDeviceRegistryPropertyW(NULL, NULL, -1, NULL, 0);
1105     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
1106      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
1107     SetLastError(0xdeadbeef);
1108     ret = pSetupDiSetDeviceRegistryPropertyW(set, NULL, -1, NULL, 0);
1109     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
1110      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
1111     SetLastError(0xdeadbeef);
1112     ret = pSetupDiSetDeviceRegistryPropertyW(set, &devInfo, -1, NULL, 0);
1113     todo_wine
1114     ok(!ret && GetLastError() == ERROR_INVALID_REG_PROPERTY,
1115      "Expected ERROR_INVALID_REG_PROPERTY, got %08x\n", GetLastError());
1116     /* GetLastError() returns nonsense in win2k3 */
1117     ret = pSetupDiSetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1118      NULL, 0);
1119     todo_wine
1120     ok(!ret, "Expected failure, got %d\n", ret);
1121     SetLastError(0xdeadbeef);
1122     ret = pSetupDiSetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1123      (PBYTE)friendlyName, buflen);
1124     ok(ret, "SetupDiSetDeviceRegistryPropertyW failed: %08x\n", GetLastError());
1125     SetLastError(0xdeadbeef);
1126     ret = pSetupDiGetDeviceRegistryPropertyW(NULL, NULL, -1, NULL, NULL, 0, NULL);
1127     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
1128      "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
1129     SetLastError(0xdeadbeef);
1130     ret = pSetupDiGetDeviceRegistryPropertyW(set, NULL, -1, NULL, NULL, 0, NULL);
1131     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
1132      "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
1133     SetLastError(0xdeadbeef);
1134     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, -1, NULL, NULL, 0, NULL);
1135     todo_wine
1136     ok(!ret && GetLastError() == ERROR_INVALID_REG_PROPERTY,
1137      "Expected ERROR_INVALID_REG_PROPERTY, got %08x\n", GetLastError());
1138     /* GetLastError() returns nonsense in win2k3 */
1139     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1140      NULL, NULL, buflen, NULL);
1141     ok(!ret, "Expected failure, got %d\n", ret);
1142     SetLastError(0xdeadbeef);
1143     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1144      NULL, NULL, 0, &size);
1145     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1146      "Expected ERROR_INSUFFICIENT_BUFFER, got %08x\n", GetLastError());
1147     ok(buflen == size, "Unexpected size: %d\n", size);
1148     SetLastError(0xdeadbeef);
1149     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1150      NULL, (PBYTE)buf, buflen, NULL);
1151     ok(ret, "SetupDiGetDeviceRegistryPropertyW failed: %08x\n", GetLastError());
1152     ok(!lstrcmpiW(friendlyName, buf), "Unexpected property\n");
1153     SetLastError(0xdeadbeef);
1154     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1155      &regType, (PBYTE)buf, buflen, NULL);
1156     ok(ret, "SetupDiGetDeviceRegistryPropertyW failed: %08x\n", GetLastError());
1157     ok(!lstrcmpiW(friendlyName, buf), "Unexpected value of property\n");
1158     ok(regType == REG_SZ, "Unexpected type of property: %d\n", regType);
1159     SetLastError(0xdeadbeef);
1160     ret = pSetupDiSetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1161      NULL, 0);
1162     ok(ret, "SetupDiSetDeviceRegistryPropertyW failed: %08x\n", GetLastError());
1163     SetLastError(0xdeadbeef);
1164     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, SPDRP_FRIENDLYNAME,
1165      NULL, (PBYTE)buf, buflen, &size);
1166     todo_wine
1167     ok(!ret && GetLastError() == ERROR_INVALID_DATA,
1168      "Expected ERROR_INVALID_DATA, got %08x\n", GetLastError());
1169     ret = pSetupDiGetDeviceRegistryPropertyW(set, &devInfo, SPDRP_HARDWAREID,
1170      NULL, NULL, 0, &size);
1171     ok(!ret && GetLastError() == ERROR_INVALID_DATA,
1172      "Expected ERROR_INVALID_DATA, got %08x\n", GetLastError());
1173     pSetupDiDestroyDeviceInfoList(set);
1174
1175     res = RegOpenKeyW(HKEY_LOCAL_MACHINE, bogus, &key);
1176     if(!is_wow64)
1177         todo_wine ok(res == ERROR_FILE_NOT_FOUND, "Expected key to not exist\n");
1178     /* FIXME: Remove when Wine is fixed */
1179     if (res == ERROR_SUCCESS)
1180     {
1181         /* Wine doesn't delete the information currently */
1182         RegDeleteKeyW(HKEY_LOCAL_MACHINE, bogus);
1183     }
1184 }
1185
1186 static void testSetupDiGetINFClassA(void)
1187 {
1188     static const char inffile[] = "winetest.inf";
1189     static const char content[] = "[Version]\r\n\r\n";
1190     static const char* signatures[] = {"\"$CHICAGO$\"", "\"$Windows NT$\""};
1191
1192     char cn[MAX_PATH];
1193     char filename[MAX_PATH];
1194     DWORD count;
1195     BOOL retval;
1196     GUID guid;
1197     HANDLE h;
1198     int i;
1199
1200     if(!pSetupDiGetINFClassA)
1201     {
1202         win_skip("SetupDiGetINFClassA not present\n");
1203         return;
1204     }
1205
1206     count = GetTempPathA(MAX_PATH, filename);
1207     if(!count)
1208     {
1209         win_skip("GetTempPathA failed\n");
1210         return;
1211     }
1212
1213     strcat(filename, inffile);
1214     DeleteFileA(filename);
1215
1216     /* not existing file */
1217     SetLastError(0xdeadbeef);
1218     retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1219     ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1220     if (ERROR_CALL_NOT_IMPLEMENTED == GetLastError())
1221     {
1222         skip("SetupDiGetINFClassA is not implemented\n");
1223         return;
1224     }
1225     ok(ERROR_FILE_NOT_FOUND == GetLastError(),
1226         "expected error ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
1227
1228     /* missing file wins against other invalid parameter */
1229     SetLastError(0xdeadbeef);
1230     retval = SetupDiGetINFClassA(filename, NULL, cn, MAX_PATH, &count);
1231     ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1232     ok(ERROR_FILE_NOT_FOUND == GetLastError(),
1233         "expected error ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
1234
1235     SetLastError(0xdeadbeef);
1236     retval = SetupDiGetINFClassA(filename, &guid, NULL, MAX_PATH, &count);
1237     ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1238     ok(ERROR_FILE_NOT_FOUND == GetLastError(),
1239         "expected error ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
1240
1241     SetLastError(0xdeadbeef);
1242     retval = SetupDiGetINFClassA(filename, &guid, cn, 0, &count);
1243     ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1244     ok(ERROR_FILE_NOT_FOUND == GetLastError(),
1245         "expected error ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
1246
1247     SetLastError(0xdeadbeef);
1248     retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, NULL);
1249     ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1250     ok(ERROR_FILE_NOT_FOUND == GetLastError(),
1251         "expected error ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
1252
1253     /* test file content */
1254     h = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1255                     FILE_ATTRIBUTE_NORMAL, NULL);
1256     if(h == INVALID_HANDLE_VALUE)
1257     {
1258         win_skip("failed to create file %s (error %u)\n", filename, GetLastError());
1259         return;
1260     }
1261     CloseHandle( h);
1262
1263     retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1264     ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1265
1266     for(i=0; i < sizeof(signatures)/sizeof(char*); i++)
1267     {
1268         trace("testing signature %s\n", signatures[i]);
1269         h = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1270                         FILE_ATTRIBUTE_NORMAL, NULL);
1271         if(h == INVALID_HANDLE_VALUE)
1272         {
1273             win_skip("failed to create file %s (error %u)\n", filename, GetLastError());
1274             return;
1275         }
1276         WriteFile( h, content, sizeof(content), &count, NULL);
1277         CloseHandle( h);
1278
1279         retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1280         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1281
1282         WritePrivateProfileStringA("Version", "Signature", signatures[i], filename);
1283
1284         retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1285         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1286
1287         WritePrivateProfileStringA("Version", "Class", "WINE", filename);
1288
1289         count = 0xdeadbeef;
1290         retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1291         ok(retval, "expected SetupDiGetINFClassA to succeed! error %u\n", GetLastError());
1292         ok(count == 5, "expected count==5, got %u\n", count);
1293
1294         count = 0xdeadbeef;
1295         retval = SetupDiGetINFClassA(filename, &guid, cn, 5, &count);
1296         ok(retval, "expected SetupDiGetINFClassA to succeed! error %u\n", GetLastError());
1297         ok(count == 5, "expected count==5, got %u\n", count);
1298
1299         count = 0xdeadbeef;
1300         SetLastError(0xdeadbeef);
1301         retval = SetupDiGetINFClassA(filename, &guid, cn, 4, &count);
1302         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1303         ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
1304             "expected error ERROR_INSUFFICIENT_BUFFER, got %u\n", GetLastError());
1305         ok(count == 5, "expected count==5, got %u\n", count);
1306
1307         /* invalid parameter */
1308         SetLastError(0xdeadbeef);
1309         retval = SetupDiGetINFClassA(NULL, &guid, cn, MAX_PATH, &count);
1310         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1311         ok(ERROR_INVALID_PARAMETER == GetLastError(),
1312             "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1313
1314         SetLastError(0xdeadbeef);
1315         retval = SetupDiGetINFClassA(filename, NULL, cn, MAX_PATH, &count);
1316         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1317         ok(ERROR_INVALID_PARAMETER == GetLastError(),
1318             "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1319
1320         SetLastError(0xdeadbeef);
1321         retval = SetupDiGetINFClassA(filename, &guid, NULL, MAX_PATH, &count);
1322         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1323         ok(ERROR_INVALID_PARAMETER == GetLastError(),
1324             "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1325
1326         SetLastError(0xdeadbeef);
1327         retval = SetupDiGetINFClassA(filename, &guid, cn, 0, &count);
1328         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1329         ok(ERROR_INSUFFICIENT_BUFFER == GetLastError() ||
1330            ERROR_INVALID_PARAMETER == GetLastError(),
1331             "expected error ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER, "
1332             "got %u\n", GetLastError());
1333
1334         DeleteFileA(filename);
1335
1336         WritePrivateProfileStringA("Version", "Signature", signatures[i], filename);
1337         WritePrivateProfileStringA("Version", "ClassGUID", "WINE", filename);
1338
1339         SetLastError(0xdeadbeef);
1340         retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1341         ok(!retval, "expected SetupDiGetINFClassA to fail!\n");
1342         ok(RPC_S_INVALID_STRING_UUID == GetLastError() ||
1343            ERROR_INVALID_PARAMETER == GetLastError(),
1344             "expected error RPC_S_INVALID_STRING_UUID or ERROR_INVALID_PARAMETER, "
1345             "got %u\n", GetLastError());
1346
1347         /* network adapter guid */
1348         WritePrivateProfileStringA("Version", "ClassGUID",
1349                                    "{4d36e972-e325-11ce-bfc1-08002be10318}", filename);
1350
1351         /* this test succeeds only if the guid is known to the system */
1352         count = 0xdeadbeef;
1353         retval = SetupDiGetINFClassA(filename, &guid, cn, MAX_PATH, &count);
1354         ok(retval, "expected SetupDiGetINFClassA to succeed! error %u\n", GetLastError());
1355         todo_wine
1356         ok(count == 4, "expected count==4, got %u(%s)\n", count, cn);
1357
1358         DeleteFileA(filename);
1359     }
1360 }
1361
1362 static void testSetupDiGetClassDevsA(void)
1363 {
1364     static GUID displayguid = {0x4d36e968, 0xe325, 0x11ce, {0xbf,0xc1,0x08,0x00,0x2b,0xe1,0x03,0x18}};
1365     SP_DEVINFO_DATA devinfo;
1366     DISPLAY_DEVICEA disp;
1367     HDEVINFO set;
1368     BOOL ret;
1369
1370     disp.cb = sizeof(disp);
1371     ok(EnumDisplayDevicesA(NULL, 0, &disp, 0), "EnumDisplayDevices failed: %08x\n", GetLastError());
1372
1373     SetLastError(0xdeadbeef);
1374     set = pSetupDiGetClassDevsA(&displayguid, disp.DeviceID, 0, 0);
1375     ok(set != INVALID_HANDLE_VALUE, "SetupDiGetClassDevsA failed: %08x\n", GetLastError());
1376
1377     devinfo.cbSize = sizeof(devinfo);
1378     ret = SetupDiEnumDeviceInfo(set, 0, &devinfo);
1379     ok(ret, "SetupDiEnumDeviceInfo failed: %08x\n", GetLastError());
1380
1381     pSetupDiDestroyDeviceInfoList(set);
1382 }
1383
1384 START_TEST(devinst)
1385 {
1386     HKEY hkey;
1387
1388     init_function_pointers();
1389
1390     if ((hkey = SetupDiOpenClassRegKey(NULL, KEY_ALL_ACCESS)) == INVALID_HANDLE_VALUE)
1391     {
1392         skip("needs admin rights\n");
1393         return;
1394     }
1395     RegCloseKey(hkey);
1396
1397     if (pIsWow64Process)
1398         pIsWow64Process(GetCurrentProcess(), &is_wow64);
1399
1400     if (pSetupDiCreateDeviceInfoListExW)
1401         test_SetupDiCreateDeviceInfoListEx();
1402     else
1403         win_skip("SetupDiCreateDeviceInfoListExW is not available\n");
1404
1405     if (pSetupDiOpenClassRegKeyExA)
1406         test_SetupDiOpenClassRegKeyExA();
1407     else
1408         win_skip("SetupDiOpenClassRegKeyExA is not available\n");
1409
1410     testInstallClass();
1411     testCreateDeviceInfo();
1412     testGetDeviceInstanceId();
1413     testRegisterDeviceInfo();
1414     testCreateDeviceInterface();
1415     testGetDeviceInterfaceDetail();
1416     testDevRegKey();
1417     testRegisterAndGetDetail();
1418     testDeviceRegistryPropertyA();
1419     testDeviceRegistryPropertyW();
1420     if (!winetest_interactive)
1421     {
1422         win_skip("testSetupDiGetINFClassA(), ROSTESTS-66.\n");
1423     }
1424     else
1425     {
1426         testSetupDiGetINFClassA();
1427     }
1428     testSetupDiGetClassDevsA();
1429 }