projects / reactos.git / blob
? search:


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