ReactOS 0.4.15-dev-7788-g1ad9096
shreg.c
Go to the documentation of this file.
1/* Unit test suite for SHReg* functions
2 *
3 * Copyright 2002 Juergen Schmied
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20#include <stdarg.h>
21#include <stdio.h>
22
23#include "wine/test.h"
24#include "windef.h"
25#include "winbase.h"
26#include "winerror.h"
27#include "winreg.h"
28#include "winuser.h"
29#include "shlwapi.h"
30
31/* Keys used for testing */
32#define REG_TEST_KEY "Software\\Wine\\Test"
33#define REG_CURRENT_VERSION "Software\\Microsoft\\Windows\\CurrentVersion\\explorer"
34
36
37static DWORD (WINAPI *pSHCopyKeyA)(HKEY,LPCSTR,HKEY,DWORD);
38static DWORD (WINAPI *pSHRegGetPathA)(HKEY,LPCSTR,LPCSTR,LPSTR,DWORD);
40static LSTATUS (WINAPI *pSHRegCreateUSKeyW)(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
41static LSTATUS (WINAPI *pSHRegOpenUSKeyW)(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
42static LSTATUS (WINAPI *pSHRegCloseUSKey)(HUSKEY);
43
44static const char sTestpath1[] = "%LONGSYSTEMVAR%\\subdir1";
45static const char sTestpath2[] = "%FOO%\\subdir1";
46
47static const char * sEnvvar1 = "bar";
48static const char * sEnvvar2 = "ImARatherLongButIndeedNeededString";
49
54
55static const char * sEmptyBuffer ="0123456789";
56
57/* delete key and all its subkeys */
58static DWORD delete_key( HKEY hkey, LPCSTR parent, LPCSTR keyname )
59{
60 HKEY parentKey;
61 DWORD ret;
62
63 RegCloseKey(hkey);
64
65 /* open the parent of the key to close */
67 if (ret != ERROR_SUCCESS)
68 return ret;
69
70 ret = SHDeleteKeyA( parentKey, keyname );
71 RegCloseKey(parentKey);
72
73 return ret;
74}
75
77{
78 HKEY hKey;
79 DWORD ret;
80 DWORD nExpectedLen1, nExpectedLen2;
81
82 SetEnvironmentVariableA("LONGSYSTEMVAR", sEnvvar1);
84
86 ok( ERROR_SUCCESS == ret, "RegCreateKeyA failed, ret=%u\n", ret);
87
88 if (hKey)
89 {
90 ok(!RegSetValueExA(hKey,"Test1",0,REG_EXPAND_SZ, (LPBYTE) sTestpath1, strlen(sTestpath1)+1), "RegSetValueExA failed\n");
91 ok(!RegSetValueExA(hKey,"Test2",0,REG_SZ, (LPBYTE) sTestpath1, strlen(sTestpath1)+1), "RegSetValueExA failed\n");
92 ok(!RegSetValueExA(hKey,"Test3",0,REG_EXPAND_SZ, (LPBYTE) sTestpath2, strlen(sTestpath2)+1), "RegSetValueExA failed\n");
93 }
94
97
98 nExpectedLen1 = strlen(sTestpath1) - strlen("%LONGSYSTEMVAR%") + strlen(sEnvvar1) + 1;
99 nExpectedLen2 = strlen(sTestpath2) - strlen("%FOO%") + strlen(sEnvvar2) + 1;
100 /* ExpandEnvironmentStringsA on NT4 returns 2x the correct result */
101 trace("sExplen1 = (%d)\n", nExpLen1);
102 if (nExpectedLen1 != nExpLen1)
103 trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath1, nExpectedLen1 );
104
105 trace("sExplen2 = (%d)\n", nExpLen2);
106 if (nExpectedLen2 != nExpLen2)
107 trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath2, nExpectedLen2 );
108
109 /* Make sure we carry on with correct values */
110 nExpLen1 = nExpectedLen1;
111 nExpLen2 = nExpectedLen2;
112 return hKey;
113}
114
115static void test_SHGetValue(void)
116{
118 DWORD dwType;
119 DWORD dwRet;
120 char buf[MAX_PATH];
121
124 dwType = -1;
125 dwRet = SHGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", &dwType, buf, &dwSize);
126 ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%u\n", dwRet);
127 ok( 0 == strcmp(sExpTestpath1, buf) ||
128 broken(0 == strcmp(sTestpath1, buf)), /* IE4.x */
129 "Comparing of (%s) with (%s) failed\n", buf, sExpTestpath1);
130 ok( REG_SZ == dwType ||
131 broken(REG_EXPAND_SZ == dwType), /* IE4.x */
132 "Expected REG_SZ, got (%u)\n", dwType);
133
136 dwType = -1;
137 dwRet = SHGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", &dwType, buf, &dwSize);
138 ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%u\n", dwRet);
139 ok( 0 == strcmp(sTestpath1, buf) , "Comparing of (%s) with (%s) failed\n", buf, sTestpath1);
140 ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
141}
142
143static void test_SHRegGetValue(void)
144{
145 LSTATUS ret;
146 DWORD size, type;
147 char data[MAX_PATH];
148
149 if(!pSHRegGetValueA)
150 return;
151
152 size = MAX_PATH;
153 ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", SRRF_RT_REG_EXPAND_SZ, &type, data, &size);
154 ok(ret == ERROR_INVALID_PARAMETER, "SHRegGetValue failed, ret=%u\n", ret);
155
156 size = MAX_PATH;
157 ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", SRRF_RT_REG_SZ, &type, data, &size);
158 ok(ret == ERROR_SUCCESS, "SHRegGetValue failed, ret=%u\n", ret);
159 ok(!strcmp(data, sExpTestpath1), "data = %s, expected %s\n", data, sExpTestpath1);
160 ok(type == REG_SZ, "type = %d, expected REG_SZ\n", type);
161
162 size = MAX_PATH;
163 ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", SRRF_RT_REG_DWORD, &type, data, &size);
164 ok(ret == ERROR_UNSUPPORTED_TYPE, "SHRegGetValue failed, ret=%u\n", ret);
165
166 size = MAX_PATH;
167 ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", SRRF_RT_REG_EXPAND_SZ, &type, data, &size);
168 ok(ret == ERROR_INVALID_PARAMETER, "SHRegGetValue failed, ret=%u\n", ret);
169
170 size = MAX_PATH;
171 ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", SRRF_RT_REG_SZ, &type, data, &size);
172 ok(ret == ERROR_SUCCESS, "SHRegGetValue failed, ret=%u\n", ret);
173 ok(!strcmp(data, sTestpath1), "data = %s, expected %s\n", data, sTestpath1);
174 ok(type == REG_SZ, "type = %d, expected REG_SZ\n", type);
175
176 size = MAX_PATH;
177 ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", SRRF_RT_REG_QWORD, &type, data, &size);
178 ok(ret == ERROR_UNSUPPORTED_TYPE, "SHRegGetValue failed, ret=%u\n", ret);
179}
180
181static void test_SHGetRegPath(void)
182{
183 char buf[MAX_PATH];
184 DWORD dwRet;
185
186 if (!pSHRegGetPathA)
187 return;
188
190 dwRet = (*pSHRegGetPathA)(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", buf, 0);
191 ok( ERROR_SUCCESS == dwRet, "SHRegGetPathA failed, ret=%u\n", dwRet);
192 ok( 0 == strcmp(sExpTestpath1, buf) , "Comparing (%s) with (%s) failed\n", buf, sExpTestpath1);
193}
194
195static void test_SHQueryValueEx(void)
196{
197 HKEY hKey;
199 DWORD dwType;
200 char buf[MAX_PATH];
201 DWORD dwRet;
202 const char * sTestedFunction = "";
203 DWORD nUsedBuffer1,nUsedBuffer2;
204
205 sTestedFunction = "RegOpenKeyExA";
207 ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
208
209 /****** SHQueryValueExA ******/
210
211 sTestedFunction = "SHQueryValueExA";
212 nUsedBuffer1 = max(strlen(sExpTestpath1)+1, strlen(sTestpath1)+1);
213 nUsedBuffer2 = max(strlen(sExpTestpath2)+1, strlen(sTestpath2)+1);
214 /*
215 * Case 1.1 All arguments are NULL
216 */
217 dwRet = SHQueryValueExA( hKey, "Test1", NULL, NULL, NULL, NULL);
218 ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
219
220 /*
221 * Case 1.2 dwType is set
222 */
223 dwType = -1;
224 dwRet = SHQueryValueExA( hKey, "Test1", NULL, &dwType, NULL, NULL);
225 ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
226 ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
227
228 /*
229 * dwSize is set
230 * dwExpanded < dwUnExpanded
231 */
232 dwSize = 6;
233 dwRet = SHQueryValueExA( hKey, "Test1", NULL, NULL, NULL, &dwSize);
234 ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
235 ok( dwSize == nUsedBuffer1, "Buffer sizes (%u) and (%u) are not equal\n", dwSize, nUsedBuffer1);
236
237 /*
238 * dwExpanded > dwUnExpanded
239 */
240 dwSize = 6;
241 dwRet = SHQueryValueExA( hKey, "Test3", NULL, NULL, NULL, &dwSize);
242 ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
243 ok( dwSize >= nUsedBuffer2 ||
244 broken(dwSize == (strlen(sTestpath2) + 1)), /* < IE4.x */
245 "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
246
247 /*
248 * Case 1 string shrinks during expanding
249 */
251 dwSize = 6;
252 dwType = -1;
253 dwRet = SHQueryValueExA( hKey, "Test1", NULL, &dwType, buf, &dwSize);
254 ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
255 ok( 0 == strcmp(sEmptyBuffer, buf) , "Comparing (%s) with (%s) failed\n", buf, sEmptyBuffer);
256 ok( dwSize == nUsedBuffer1, "Buffer sizes (%u) and (%u) are not equal\n", dwSize, nUsedBuffer1);
257 ok( REG_SZ == dwType ||
258 broken(REG_EXPAND_SZ == dwType), /* < IE6 */
259 "Expected REG_SZ, got (%u)\n", dwType);
260
261 /*
262 * string grows during expanding
263 * dwSize is smaller than the size of the unexpanded string
264 */
266 dwSize = 6;
267 dwType = -1;
268 dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize);
269 ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
270 ok( 0 == strcmp(sEmptyBuffer, buf) , "Comparing (%s) with (%s) failed\n", buf, sEmptyBuffer);
271 ok( dwSize >= nUsedBuffer2 ||
272 broken(dwSize == (strlen(sTestpath2) + 1)), /* < IE6 */
273 "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
274 ok( REG_SZ == dwType ||
275 broken(REG_EXPAND_SZ == dwType), /* < IE6 */
276 "Expected REG_SZ, got (%u)\n", dwType);
277
278 /*
279 * string grows during expanding
280 * dwSize is larger than the size of the unexpanded string, but
281 * smaller than the part before the backslash. If the unexpanded
282 * string fits into the buffer, it can get cut when expanded.
283 */
285 dwSize = strlen(sEnvvar2) - 2;
286 dwType = -1;
287 dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize);
288 ok( ERROR_MORE_DATA == dwRet ||
289 broken(ERROR_ENVVAR_NOT_FOUND == dwRet) || /* IE5.5 */
290 broken(ERROR_SUCCESS == dwRet), /* < IE5.5*/
291 "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
292
294 {
295 ok( (0 == strcmp("", buf)) || (0 == strcmp(sTestpath2, buf)),
296 "Expected empty or unexpanded string (win98), got (%s)\n", buf);
297 }
298
299 ok( dwSize >= nUsedBuffer2 ||
300 broken(dwSize == (strlen("") + 1)), /* < IE 5.5 */
301 "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
302 ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
303
304 /*
305 * string grows during expanding
306 * dwSize is larger than the size of the part before the backslash,
307 * but smaller than the expanded string. If the unexpanded string fits
308 * into the buffer, it can get cut when expanded.
309 */
311 dwSize = nExpLen2 - 4;
312 dwType = -1;
313 dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize);
314 ok( ERROR_MORE_DATA == dwRet ||
315 broken(ERROR_ENVVAR_NOT_FOUND == dwRet) || /* IE5.5 */
316 broken(ERROR_SUCCESS == dwRet), /* < IE5.5 */
317 "Expected ERROR_MORE_DATA, got (%u)\n", dwRet);
318
320 {
321 ok( (0 == strcmp("", buf)) || (0 == strcmp(sEnvvar2, buf)) ||
322 broken(0 == strcmp(sTestpath2, buf)), /* IE 5.5 */
323 "Expected empty or first part of the string \"%s\", got \"%s\"\n", sEnvvar2, buf);
324 }
325
326 ok( dwSize >= nUsedBuffer2 ||
327 broken(dwSize == (strlen(sEnvvar2) + 1)) || /* IE4.01 SP1 (W98) and IE5 (W98SE) */
328 broken(dwSize == (strlen("") + 1)), /* IE4.01 (NT4) and IE5.x (W2K) */
329 "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
330 ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
331
332 /*
333 * The buffer is NULL but the size is set
334 */
336 dwSize = 6;
337 dwType = -1;
338 dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, NULL, &dwSize);
339 ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet);
340 ok( dwSize >= nUsedBuffer2 ||
341 broken(dwSize == (strlen(sTestpath2) + 1)), /* IE4.01 SP1 (Win98) */
342 "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2);
343 ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType);
344
346}
347
348static void test_SHCopyKey(void)
349{
350 HKEY hKeySrc, hKeyDst;
351 DWORD dwRet;
352
353 if (!pSHCopyKeyA)
354 {
355 win_skip("SHCopyKeyA is not available\n");
356 return;
357 }
358
359 /* Delete existing destination sub keys */
360 hKeyDst = NULL;
361 if (!RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\CopyDestination", &hKeyDst) && hKeyDst)
362 {
363 SHDeleteKeyA(hKeyDst, NULL);
364 RegCloseKey(hKeyDst);
365 }
366
367 hKeyDst = NULL;
368 dwRet = RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\CopyDestination", &hKeyDst);
369 if (dwRet || !hKeyDst)
370 {
371 ok( 0, "Destination couldn't be created, RegCreateKeyA returned (%u)\n", dwRet);
372 return;
373 }
374
375 hKeySrc = NULL;
377 if (dwRet || !hKeySrc)
378 {
379 ok( 0, "Source couldn't be opened, RegOpenKeyA returned (%u)\n", dwRet);
380 RegCloseKey(hKeyDst);
381 return;
382 }
383
384 dwRet = (*pSHCopyKeyA)(hKeySrc, NULL, hKeyDst, 0);
385 ok ( ERROR_SUCCESS == dwRet, "Copy failed, ret=(%u)\n", dwRet);
386
387 RegCloseKey(hKeySrc);
388 RegCloseKey(hKeyDst);
389
390 /* Check we copied the sub keys, i.e. something that's on every windows system (including Wine) */
391 hKeyDst = NULL;
392 dwRet = RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\CopyDestination\\Shell Folders", &hKeyDst);
393 if (dwRet || !hKeyDst)
394 {
395 ok ( 0, "Copy couldn't be opened, RegOpenKeyA returned (%u)\n", dwRet);
396 return;
397 }
398
399 /* And the we copied the values too */
400 ok(!SHQueryValueExA(hKeyDst, "Common AppData", NULL, NULL, NULL, NULL), "SHQueryValueExA failed\n");
401
402 RegCloseKey(hKeyDst);
403}
404
405static void test_SHDeleteKey(void)
406{
407 HKEY hKeyTest, hKeyS;
408 DWORD dwRet;
409 int sysfail = 1;
410
412 {
413 if (!RegCreateKeyA(hKeyTest, "ODBC", &hKeyS))
414 {
415 HKEY hKeyO;
416
417 if (!RegCreateKeyA(hKeyS, "ODBC.INI", &hKeyO))
418 {
419 RegCloseKey (hKeyO);
420
421 if (!RegCreateKeyA(hKeyS, "ODBCINST.INI", &hKeyO))
422 {
423 RegCloseKey (hKeyO);
424 sysfail = 0;
425 }
426 }
427 RegCloseKey (hKeyS);
428 }
429 RegCloseKey (hKeyTest);
430 }
431
432 if (!sysfail)
433 {
434
436 ok ( ERROR_SUCCESS == dwRet, "SHDeleteKey failed, ret=(%u)\n", dwRet);
437
438 dwRet = RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\\ODBC", &hKeyS);
439 ok ( ERROR_FILE_NOT_FOUND == dwRet, "SHDeleteKey did not delete\n");
440
441 if (dwRet == ERROR_SUCCESS)
442 RegCloseKey (hKeyS);
443 }
444 else
445 ok( 0, "Could not set up SHDeleteKey test\n");
446}
447
448static void test_SHRegCreateUSKeyW(void)
449{
450 static const WCHAR subkeyW[] = {'s','u','b','k','e','y',0};
451 LONG ret;
452
453 if (!pSHRegCreateUSKeyW)
454 {
455 win_skip("SHRegCreateUSKeyW not available\n");
456 return;
457 }
458
459 ret = pSHRegCreateUSKeyW(subkeyW, KEY_ALL_ACCESS, NULL, NULL, SHREGSET_FORCE_HKCU);
460 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
461}
462
463static void test_SHRegCloseUSKey(void)
464{
465 static const WCHAR localW[] = {'S','o','f','t','w','a','r','e',0};
466 LONG ret;
467 HUSKEY key;
468
469 if (!pSHRegOpenUSKeyW || !pSHRegCloseUSKey)
470 {
471 win_skip("SHRegOpenUSKeyW or SHRegCloseUSKey not available\n");
472 return;
473 }
474
475 ret = pSHRegCloseUSKey(NULL);
476 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
477
478 ret = pSHRegOpenUSKeyW(localW, KEY_ALL_ACCESS, NULL, &key, FALSE);
479 ok(ret == ERROR_SUCCESS, "got %d\n", ret);
480
481 ret = pSHRegCloseUSKey(key);
482 ok(ret == ERROR_SUCCESS, "got %d\n", ret);
483
484 /* Test with limited rights, specially without KEY_SET_VALUE */
485 ret = pSHRegOpenUSKeyW(localW, KEY_QUERY_VALUE, NULL, &key, FALSE);
486 ok(ret == ERROR_SUCCESS, "got %d\n", ret);
487
488 ret = pSHRegCloseUSKey(key);
489 ok(ret == ERROR_SUCCESS, "got %d\n", ret);
490}
491
493{
494 HKEY hkey = create_test_entries();
495
496 if (!hkey) return;
497
498 hshlwapi = GetModuleHandleA("shlwapi.dll");
499
500 /* SHCreateStreamOnFileEx was introduced in shlwapi v6.0 */
501 if(!GetProcAddress(hshlwapi, "SHCreateStreamOnFileEx")){
502 win_skip("Too old shlwapi version\n");
503 return;
504 }
505
506 pSHCopyKeyA = (void*)GetProcAddress(hshlwapi,"SHCopyKeyA");
507 pSHRegGetPathA = (void*)GetProcAddress(hshlwapi,"SHRegGetPathA");
508 pSHRegGetValueA = (void*)GetProcAddress(hshlwapi,"SHRegGetValueA");
509 pSHRegCreateUSKeyW = (void*)GetProcAddress(hshlwapi, "SHRegCreateUSKeyW");
510 pSHRegOpenUSKeyW = (void*)GetProcAddress(hshlwapi, "SHRegOpenUSKeyW");
511 pSHRegCloseUSKey = (void*)GetProcAddress(hshlwapi, "SHRegCloseUSKey");
512
521
522 delete_key( hkey, "Software\\Wine", "Test" );
523}
#define broken(x)
Definition: _sntprintf.h:21
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
void sysfail(const char *what, int errnoval)
Definition: adh-main.c:49
#define trace
Definition: atltest.h:70
#define ok(value,...)
Definition: atltest.h:57
#define START_TEST(x)
Definition: atltest.h:75
#define RegCloseKey(hKey)
Definition: registry.h:49
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
LONG WINAPI RegCreateKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:1179
LONG WINAPI RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Definition: reg.c:4828
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3327
LONG WINAPI RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3263
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define GetProcAddress(x, y)
Definition: compat.h:753
#define MAX_PATH
Definition: compat.h:34
DWORD WINAPI ExpandEnvironmentStringsA(IN LPCSTR lpSrc, IN LPSTR lpDst, IN DWORD nSize)
Definition: environ.c:399
BOOL WINAPI DECLSPEC_HOTPATCH SetEnvironmentVariableA(IN LPCSTR lpName, IN LPCSTR lpValue)
Definition: environ.c:218
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1207
DWORD WINAPI SHQueryValueExA(HKEY hKey, LPCSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1402
DWORD WINAPI SHDeleteKeyA(HKEY hKey, LPCSTR lpszSubKey)
Definition: reg.c:1533
r parent
Definition: btrfs.c:3010
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define REG_SZ
Definition: layer.c:22
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define todo_wine
Definition: custom.c:79
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
long LONG
Definition: pedump.c:60
#define delete_key(r, p, s)
Definition: reg_test.h:64
#define win_skip
Definition: test.h:160
#define SRRF_RT_REG_EXPAND_SZ
Definition: shlwapi.h:243
#define SRRF_RT_REG_DWORD
Definition: shlwapi.h:245
#define SRRF_RT_REG_QWORD
Definition: shlwapi.h:247
#define SRRF_RT_REG_SZ
Definition: shlwapi.h:242
#define SHREGSET_FORCE_HKCU
Definition: shlwapi.h:312
static void test_SHQueryValueEx(void)
Definition: shreg.c:195
static LPSTR
Definition: shreg.c:38
static const char * sEmptyBuffer
Definition: shreg.c:55
static DWORD nExpLen1
Definition: shreg.c:52
static void test_SHDeleteKey(void)
Definition: shreg.c:405
static void test_SHGetValue(void)
Definition: shreg.c:115
static void test_SHCopyKey(void)
Definition: shreg.c:348
static BOOL
Definition: shreg.c:41
static HKEY create_test_entries(void)
Definition: shreg.c:76
static DWORD nExpLen2
Definition: shreg.c:53
static const char * sEnvvar2
Definition: shreg.c:48
static const char sTestpath2[]
Definition: shreg.c:45
static const char * sEnvvar1
Definition: shreg.c:47
static REGSAM
Definition: shreg.c:40
static void test_SHGetRegPath(void)
Definition: shreg.c:181
#define REG_CURRENT_VERSION
Definition: shreg.c:33
static DWORD
Definition: shreg.c:37
static const char sTestpath1[]
Definition: shreg.c:44
static SRRF
Definition: shreg.c:39
static char sExpTestpath1[MAX_PATH]
Definition: shreg.c:50
static HUSKEY
Definition: shreg.c:40
static void test_SHRegCloseUSKey(void)
Definition: shreg.c:463
static HMODULE hshlwapi
Definition: shreg.c:35
static void test_SHRegCreateUSKeyW(void)
Definition: shreg.c:448
static LPVOID
Definition: shreg.c:39
static LPDWORD
Definition: shreg.c:39
static char sExpTestpath2[MAX_PATH]
Definition: shreg.c:51
static LPCSTR
Definition: shreg.c:37
#define REG_TEST_KEY
Definition: shreg.c:32
static HKEY
Definition: shreg.c:37
static PHUSKEY
Definition: shreg.c:40
static LSTATUS(WINAPI *pSHRegGetValueA)(HKEY
static void test_SHRegGetValue(void)
Definition: shreg.c:143
Definition: copy.c:22
#define max(a, b)
Definition: svc.c:63
unsigned char * LPBYTE
Definition: typedefs.h:53
int ret
#define WINAPI
Definition: msvc.h:6
#define ERROR_UNSUPPORTED_TYPE
Definition: winerror.h:988
#define ERROR_ENVVAR_NOT_FOUND
Definition: winerror.h:261
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_USER
Definition: winreg.h:11
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185