1 /*
2 * Unit tests for registry functions
3 *
4 * Copyright (c) 2002 Alexandre Julliard
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 <assert.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include "wine/test.h"
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winreg.h"
28 #include "winsvc.h"
29 #include "winerror.h"
30
31 static HKEY hkey_main;
32 static DWORD GLE;
33
34 static const char * sTestpath1 = "%LONGSYSTEMVAR%\\subdir1";
35 static const char * sTestpath2 = "%FOO%\\subdir1";
36
37 static HMODULE hadvapi32;
38 static DWORD (WINAPI *pRegGetValueA)(HKEY,LPCSTR,LPCSTR,DWORD,LPDWORD,PVOID,LPDWORD);
39 static DWORD (WINAPI *pRegDeleteTreeA)(HKEY,LPCSTR);
40
41
42
43 /* Debugging functions from wine/libs/wine/debug.c */
44
45 /* allocate some tmp string space */
46 /* FIXME: this is not 100% thread-safe */
47 static char *get_temp_buffer( int size )
48 {
49 static char *list[32];
50 static long pos;
51 char *ret;
52 int idx;
53
54 idx = ++pos % (sizeof(list)/sizeof(list[0]));
55 if ((ret = realloc( list[idx], size ))) list[idx] = ret;
56 return ret;
57 }
58
59 static const char *wine_debugstr_an( const char *str, int n )
60 {
61 static const char hex[16] = "0123456789abcdef";
62 char *dst, *res;
63 size_t size;
64
65 if (!((ULONG_PTR)str >> 16))
66 {
67 if (!str) return "(null)";
68 res = get_temp_buffer( 6 );
69 sprintf( res, "#%04x", LOWORD(str) );
70 return res;
71 }
72 if (n == -1) n = strlen(str);
73 if (n < 0) n = 0;
74 size = 10 + min( 300, n * 4 );
75 dst = res = get_temp_buffer( size );
76 *dst++ = '"';
77 while (n-- > 0 && dst <= res + size - 9)
78 {
79 unsigned char c = *str++;
80 switch (c)
81 {
82 case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
83 case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
84 case '\t': *dst++ = '\\'; *dst++ = 't'; break;
85 case '"': *dst++ = '\\'; *dst++ = '"'; break;
86 case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
87 default:
88 if (c >= ' ' && c <= 126)
89 *dst++ = c;
90 else
91 {
92 *dst++ = '\\';
93 *dst++ = 'x';
94 *dst++ = hex[(c >> 4) & 0x0f];
95 *dst++ = hex[c & 0x0f];
96 }
97 }
98 }
99 *dst++ = '"';
100 if (n > 0)
101 {
102 *dst++ = '.';
103 *dst++ = '.';
104 *dst++ = '.';
105 }
106 *dst++ = 0;
107 return res;
108 }
109
110 static const char *wine_debugstr_wn( const WCHAR *str, int n )
111 {
112 char *dst, *res;
113 size_t size;
114
115 if (!HIWORD(str))
116 {
117 if (!str) return "(null)";
118 res = get_temp_buffer( 6 );
119 sprintf( res, "#%04x", LOWORD(str) );
120 return res;
121 }
122 if (n == -1) n = lstrlenW(str);
123 if (n < 0) n = 0;
124 size = 12 + min( 300, n * 5);
125 dst = res = get_temp_buffer( n * 5 + 7 );
126 *dst++ = 'L';
127 *dst++ = '"';
128 while (n-- > 0 && dst <= res + size - 10)
129 {
130 WCHAR c = *str++;
131 switch (c)
132 {
133 case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
134 case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
135 case '\t': *dst++ = '\\'; *dst++ = 't'; break;
136 case '"': *dst++ = '\\'; *dst++ = '"'; break;
137 case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
138 default:
139 if (c >= ' ' && c <= 126)
140 *dst++ = (char)c;
141 else
142 {
143 *dst++ = '\\';
144 sprintf(dst,"%04x",c);
145 dst+=4;
146 }
147 }
148 }
149 *dst++ = '"';
150 if (n > 0)
151 {
152 *dst++ = '.';
153 *dst++ = '.';
154 *dst++ = '.';
155 }
156 *dst = 0;
157 return res;
158 }
159
160
161 #define ADVAPI32_GET_PROC(func) \
162 p ## func = (void*)GetProcAddress(hadvapi32, #func); \
163 if(!p ## func) \
164 trace("GetProcAddress(%s) failed\n", #func);
165
166 static void InitFunctionPtrs(void)
167 {
168 hadvapi32 = GetModuleHandleA("advapi32.dll");
169
170 /* This function was introduced with Windows 2003 SP1 */
171 ADVAPI32_GET_PROC(RegGetValueA)
172 ADVAPI32_GET_PROC(RegDeleteTreeA)
173 }
174
175 /* delete key and all its subkeys */
176 static DWORD delete_key( HKEY hkey )
177 {
178 char name[MAX_PATH];
179 DWORD ret;
180
181 while (!(ret = RegEnumKeyA(hkey, 0, name, sizeof(name))))
182 {
183 HKEY tmp;
184 if (!(ret = RegOpenKeyExA( hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp )))
185 {
186 ret = delete_key( tmp );
187 RegCloseKey( tmp );
188 }
189 if (ret) break;
190 }
191 if (ret != ERROR_NO_MORE_ITEMS) return ret;
192 RegDeleteKeyA( hkey, "" );
193 return 0;
194 }
195
196 static void setup_main_key(void)
197 {
198 if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkey_main )) delete_key( hkey_main );
199
200 assert (!RegCreateKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkey_main ));
201 }
202
203 static void test_hkey_main_Value_A(LPCSTR name, LPCSTR string,
204 DWORD full_byte_len)
205 {
206 DWORD ret, type, cbData;
207 DWORD str_byte_len;
208 LPSTR value;
209 static const char nA[]={'N', 0};
210
211 type=0xdeadbeef;
212 cbData=0xdeadbeef;
213 /* When successful RegQueryValueExA() leaves GLE as is,
214 * so we must reset it to detect unimplemented functions.
215 */
216 SetLastError(0xdeadbeef);
217 ret = RegQueryValueExA(hkey_main, name, NULL, &type, NULL, &cbData);
218 GLE = GetLastError();
219 ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %d, GLE=%d\n", ret, GLE);
220 /* It is wrong for the Ansi version to not be implemented */
221 ok(GLE == 0xdeadbeef, "RegQueryValueExA set GLE = %u\n", GLE);
222 if(GLE == ERROR_CALL_NOT_IMPLEMENTED) return;
223
224 str_byte_len = (string ? lstrlenA(string) : 0) + 1;
225 ok(type == REG_SZ, "RegQueryValueExA returned type %d\n", type);
226 ok(cbData == full_byte_len || cbData == str_byte_len /* Win9x */,
227 "cbData=%d instead of %d or %d\n", cbData, full_byte_len, str_byte_len);
228
229 value = HeapAlloc(GetProcessHeap(), 0, (cbData+2)*sizeof(*value));
230 strcpy(value, nA);
231 type=0xdeadbeef;
232 ret = RegQueryValueExA(hkey_main, name, NULL, &type, (BYTE*)value, &cbData);
233 GLE = GetLastError();
234 ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %d, GLE=%d\n", ret, GLE);
235 if (!string)
236 {
237 /* When cbData == 0, RegQueryValueExA() should not modify the buffer */
238 ok(strcmp(value, nA) == 0 || (cbData == 1 && *value == '\0') /* Win9x */,
239 "RegQueryValueExA failed: '%s' != '%s'\n", value, string);
240 }
241 else
242 {
243 ok(memcmp(value, string, cbData) == 0, "RegQueryValueExA failed: %s/%d != %s/%d\n",
244 wine_debugstr_an(value, cbData), cbData,
245 wine_debugstr_an(string, full_byte_len), full_byte_len);
246 }
247 HeapFree(GetProcessHeap(), 0, value);
248 }
249
250 static void test_hkey_main_Value_W(LPCWSTR name, LPCWSTR string,
251 DWORD full_byte_len)
252 {
253 DWORD ret, type, cbData;
254 LPWSTR value;
255 static const WCHAR nW[]={'N', 0};
256
257 type=0xdeadbeef;
258 cbData=0xdeadbeef;
259 /* When successful RegQueryValueExW() leaves GLE as is,
260 * so we must reset it to detect unimplemented functions.
261 */
262 SetLastError(0xdeadbeef);
263 ret = RegQueryValueExW(hkey_main, name, NULL, &type, NULL, &cbData);
264 GLE = GetLastError();
265 ok(ret == ERROR_SUCCESS, "RegQueryValueExW failed: %d, GLE=%d\n", ret, GLE);
266 if(GLE == ERROR_CALL_NOT_IMPLEMENTED)
267 {
268 win_skip("RegQueryValueExW() is not implemented\n");
269 return;
270 }
271
272 ok(type == REG_SZ, "RegQueryValueExW returned type %d\n", type);
273 ok(cbData == full_byte_len,
274 "cbData=%d instead of %d\n", cbData, full_byte_len);
275
276 value = HeapAlloc(GetProcessHeap(), 0, (cbData+2)*sizeof(*value));
277 lstrcpyW(value, nW);
278 type=0xdeadbeef;
279 ret = RegQueryValueExW(hkey_main, name, NULL, &type, (BYTE*)value, &cbData);
280 GLE = GetLastError();
281 ok(ret == ERROR_SUCCESS, "RegQueryValueExW failed: %d, GLE=%d\n", ret, GLE);
282 if (!string)
283 {
284 /* When cbData == 0, RegQueryValueExW() should not modify the buffer */
285 string=nW;
286 }
287 ok(memcmp(value, string, cbData) == 0, "RegQueryValueExW failed: %s/%d != %s/%d\n",
288 wine_debugstr_wn(value, cbData / sizeof(WCHAR)), cbData,
289 wine_debugstr_wn(string, full_byte_len / sizeof(WCHAR)), full_byte_len);
290 HeapFree(GetProcessHeap(), 0, value);
291 }
292
293 static void test_set_value(void)
294 {
295 DWORD ret;
296
297 static const WCHAR name1W[] = {'C','l','e','a','n','S','i','n','g','l','e','S','t','r','i','n','g', 0};
298 static const WCHAR name2W[] = {'S','o','m','e','I','n','t','r','a','Z','e','r','o','e','d','S','t','r','i','n','g', 0};
299 static const WCHAR emptyW[] = {0};
300 static const WCHAR string1W[] = {'T','h','i','s','N','e','v','e','r','B','r','e','a','k','s', 0};
301 static const WCHAR string2W[] = {'T','h','i','s', 0 ,'B','r','e','a','k','s', 0 , 0 ,'A', 0 , 0 , 0 , 'L','o','t', 0 , 0 , 0 , 0, 0};
302 static const WCHAR substring2W[] = {'T','h','i','s',0};
303
304 static const char name1A[] = "CleanSingleString";
305 static const char name2A[] = "SomeIntraZeroedString";
306 static const char emptyA[] = "";
307 static const char string1A[] = "ThisNeverBreaks";
308 static const char string2A[] = "This\0Breaks\0\0A\0\0\0Lot\0\0\0\0";
309 static const char substring2A[] = "This";
310
311 if (0)
312 {
313 /* Crashes on NT4, Windows 2000 and XP SP1 */
314 ret = RegSetValueA(hkey_main, NULL, REG_SZ, NULL, 0);
315 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueA should have failed with ERROR_INVALID_PARAMETER instead of %d\n", ret);
316 }
317
318 ret = RegSetValueA(hkey_main, NULL, REG_SZ, string1A, sizeof(string1A));
319 ok(ret == ERROR_SUCCESS, "RegSetValueA failed: %d, GLE=%d\n", ret, GetLastError());
320 test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
321 test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
322
323 /* RegSetValueA ignores the size passed in */
324 ret = RegSetValueA(hkey_main, NULL, REG_SZ, string1A, 4);
325 ok(ret == ERROR_SUCCESS, "RegSetValueA failed: %d, GLE=%d\n", ret, GetLastError());
326 test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
327 test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
328
329 /* stops at first null */
330 ret = RegSetValueA(hkey_main, NULL, REG_SZ, string2A, sizeof(string2A));
331 ok(ret == ERROR_SUCCESS, "RegSetValueA failed: %d, GLE=%d\n", ret, GetLastError());
332 test_hkey_main_Value_A(NULL, substring2A, sizeof(substring2A));
333 test_hkey_main_Value_W(NULL, substring2W, sizeof(substring2W));
334
335 /* only REG_SZ is supported */
336 ret = RegSetValueA(hkey_main, NULL, REG_BINARY, string2A, sizeof(string2A));
337 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueA should have returned ERROR_INVALID_PARAMETER instead of %d\n", ret);
338 ret = RegSetValueA(hkey_main, NULL, REG_EXPAND_SZ, string2A, sizeof(string2A));
339 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueA should have returned ERROR_INVALID_PARAMETER instead of %d\n", ret);
340 ret = RegSetValueA(hkey_main, NULL, REG_MULTI_SZ, string2A, sizeof(string2A));
341 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueA should have returned ERROR_INVALID_PARAMETER instead of %d\n", ret);
342
343 /* Test RegSetValueExA with a 'zero-byte' string (as Office 2003 does).
344 * Surprisingly enough we're supposed to get zero bytes out of it.
345 */
346 ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)emptyA, 0);
347 ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %d, GLE=%d\n", ret, GetLastError());
348 test_hkey_main_Value_A(name1A, NULL, 0);
349 test_hkey_main_Value_W(name1W, NULL, 0);
350
351 /* test RegSetValueExA with an empty string */
352 ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)emptyA, sizeof(emptyA));
353 ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %d, GLE=%d\n", ret, GetLastError());
354 test_hkey_main_Value_A(name1A, emptyA, sizeof(emptyA));
355 test_hkey_main_Value_W(name1W, emptyW, sizeof(emptyW));
356
357 /* test RegSetValueExA with off-by-one size */
358 ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)string1A, sizeof(string1A)-sizeof(string1A[0]));
359 ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %d, GLE=%d\n", ret, GetLastError());
360 test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
361 test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
362
363 /* test RegSetValueExA with normal string */
364 ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)string1A, sizeof(string1A));
365 ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %d, GLE=%d\n", ret, GetLastError());
366 test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
367 test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
368
369 /* test RegSetValueExA with intrazeroed string */
370 ret = RegSetValueExA(hkey_main, name2A, 0, REG_SZ, (const BYTE *)string2A, sizeof(string2A));
371 ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %d, GLE=%d\n", ret, GetLastError());
372 test_hkey_main_Value_A(name2A, string2A, sizeof(string2A));
373 test_hkey_main_Value_W(name2W, string2W, sizeof(string2W));
374
375 /* 9x doesn't support W-calls, so don't test them then */
376 if(GLE == ERROR_CALL_NOT_IMPLEMENTED) return;
377
378 if (0)
379 {
380 /* Crashes on NT4, Windows 2000 and XP SP1 */
381 ret = RegSetValueW(hkey_main, NULL, REG_SZ, NULL, 0);
382 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have failed with ERROR_INVALID_PARAMETER instead of %d\n", ret);
383 }
384
385 ret = RegSetValueW(hkey_main, NULL, REG_SZ, string1W, sizeof(string1W));
386 ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %d, GLE=%d\n", ret, GetLastError());
387 test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
388 test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
389
390 /* RegSetValueA ignores the size passed in */
391 ret = RegSetValueW(hkey_main, NULL, REG_SZ, string1W, 4 * sizeof(string1W[0]));
392 ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %d, GLE=%d\n", ret, GetLastError());
393 test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
394 test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
395
396 /* stops at first null */
397 ret = RegSetValueW(hkey_main, NULL, REG_SZ, string2W, sizeof(string2W));
398 ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %d, GLE=%d\n", ret, GetLastError());
399 test_hkey_main_Value_A(NULL, substring2A, sizeof(substring2A));
400 test_hkey_main_Value_W(NULL, substring2W, sizeof(substring2W));
401
402 /* only REG_SZ is supported */
403 ret = RegSetValueW(hkey_main, NULL, REG_BINARY, string2W, sizeof(string2W));
404 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have returned ERROR_INVALID_PARAMETER instead of %d\n", ret);
405 ret = RegSetValueW(hkey_main, NULL, REG_EXPAND_SZ, string2W, sizeof(string2W));
406 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have returned ERROR_INVALID_PARAMETER instead of %d\n", ret);
407 ret = RegSetValueW(hkey_main, NULL, REG_MULTI_SZ, string2W, sizeof(string2W));
408 ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have returned ERROR_INVALID_PARAMETER instead of %d\n", ret);
409
410 /* test RegSetValueExW with off-by-one size */
411 ret = RegSetValueExW(hkey_main, name1W, 0, REG_SZ, (const BYTE *)string1W, sizeof(string1W)-sizeof(string1W[0]));
412 ok(ret == ERROR_SUCCESS, "RegSetValueExW failed: %d, GLE=%d\n", ret, GetLastError());
413 test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
414 test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
415
416 /* test RegSetValueExW with normal string */
417 ret = RegSetValueExW(hkey_main, name1W, 0, REG_SZ, (const BYTE *)string1W, sizeof(string1W));
418 ok(ret == ERROR_SUCCESS, "RegSetValueExW failed: %d, GLE=%d\n", ret, GetLastError());
419 test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
420 test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
421
422 /* test RegSetValueExW with intrazeroed string */
423 ret = RegSetValueExW(hkey_main, name2W, 0, REG_SZ, (const BYTE *)string2W, sizeof(string2W));
424 ok(ret == ERROR_SUCCESS, "RegSetValueExW failed: %d, GLE=%d\n", ret, GetLastError());
425 test_hkey_main_Value_A(name2A, string2A, sizeof(string2A));
426 test_hkey_main_Value_W(name2W, string2W, sizeof(string2W));
427 }
428
429 static void create_test_entries(void)
430 {
431 static const DWORD qw[2] = { 0x12345678, 0x87654321 };
432
433 SetEnvironmentVariableA("LONGSYSTEMVAR", "bar");
434 SetEnvironmentVariableA("FOO", "ImARatherLongButIndeedNeededString");
435
436 ok(!RegSetValueExA(hkey_main,"TP1_EXP_SZ",0,REG_EXPAND_SZ, (const BYTE *)sTestpath1, strlen(sTestpath1)+1),
437 "RegSetValueExA failed\n");
438 ok(!RegSetValueExA(hkey_main,"TP1_SZ",0,REG_SZ, (const BYTE *)sTestpath1, strlen(sTestpath1)+1),
439 "RegSetValueExA failed\n");
440 ok(!RegSetValueExA(hkey_main,"TP1_ZB_SZ",0,REG_SZ, (const BYTE *)"", 0),
441 "RegSetValueExA failed\n");
442 ok(!RegSetValueExA(hkey_main,"TP2_EXP_SZ",0,REG_EXPAND_SZ, (const BYTE *)sTestpath2, strlen(sTestpath2)+1),
443 "RegSetValueExA failed\n");
444 ok(!RegSetValueExA(hkey_main,"DWORD",0,REG_DWORD, (const BYTE *)qw, 4),
445 "RegSetValueExA failed\n");
446 ok(!RegSetValueExA(hkey_main,"BIN32",0,REG_BINARY, (const BYTE *)qw, 4),
447 "RegSetValueExA failed\n");
448 ok(!RegSetValueExA(hkey_main,"BIN64",0,REG_BINARY, (const BYTE *)qw, 8),
449 "RegSetValueExA failed\n");
450 }
451
452 static void test_enum_value(void)
453 {
454 DWORD res;
455 HKEY test_key;
456 char value[20], data[20];
457 WCHAR valueW[20], dataW[20];
458 DWORD val_count, data_count, type;
459 static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
460 static const WCHAR testW[] = {'T','e','s','t',0};
461 static const WCHAR xxxW[] = {'x','x','x','x','x','x','x','x',0};
462
463 /* create the working key for new 'Test' value */
464 res = RegCreateKeyA( hkey_main, "TestKey", &test_key );
465 ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", res);
466
467 /* check NULL data with zero length */
468 res = RegSetValueExA( test_key, "Test", 0, REG_SZ, NULL, 0 );
469 if (GetVersion() & 0x80000000)
470 ok( res == ERROR_INVALID_PARAMETER, "RegSetValueExA returned %d\n", res );
471 else
472 ok( !res, "RegSetValueExA returned %d\n", res );
473 res = RegSetValueExA( test_key, "Test", 0, REG_EXPAND_SZ, NULL, 0 );
474 ok( ERROR_SUCCESS == res || ERROR_INVALID_PARAMETER == res, "RegSetValueExA returned %d\n", res );
475 res = RegSetValueExA( test_key, "Test", 0, REG_BINARY, NULL, 0 );
476 ok( ERROR_SUCCESS == res || ERROR_INVALID_PARAMETER == res, "RegSetValueExA returned %d\n", res );
477
478 res = RegSetValueExA( test_key, "Test", 0, REG_SZ, (const BYTE *)"foobar", 7 );
479 ok( res == 0, "RegSetValueExA failed error %d\n", res );
480
481 /* overflow both name and data */
482 val_count = 2;
483 data_count = 2;
484 type = 1234;
485 strcpy( value, "xxxxxxxxxx" );
486 strcpy( data, "xxxxxxxxxx" );
487 res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
488 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
489 ok( val_count == 2, "val_count set to %d\n", val_count );
490 ok( data_count == 7, "data_count set to %d instead of 7\n", data_count );
491 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
492 ok( !strcmp( value, "xxxxxxxxxx" ), "value set to '%s'\n", value );
493 ok( !strcmp( data, "xxxxxxxxxx" ), "data set to '%s'\n", data );
494
495 /* overflow name */
496 val_count = 3;
497 data_count = 20;
498 type = 1234;
499 strcpy( value, "xxxxxxxxxx" );
500 strcpy( data, "xxxxxxxxxx" );
501 res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
502 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
503 /* Win9x returns 2 as specified by MSDN but NT returns 3... */
504 ok( val_count == 2 || val_count == 3, "val_count set to %d\n", val_count );
505 ok( data_count == 7, "data_count set to %d instead of 7\n", data_count );
506 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
507 /* v5.1.2600.0 (XP Home and Professional) does not touch value or data in this case */
508 ok( !strcmp( value, "Te" ) || !strcmp( value, "xxxxxxxxxx" ),
509 "value set to '%s' instead of 'Te' or 'xxxxxxxxxx'\n", value );
510 ok( !strcmp( data, "foobar" ) || !strcmp( data, "xxxxxxx" ),
511 "data set to '%s' instead of 'foobar' or 'xxxxxxx'\n", data );
512
513 /* overflow empty name */
514 val_count = 0;
515 data_count = 20;
516 type = 1234;
517 strcpy( value, "xxxxxxxxxx" );
518 strcpy( data, "xxxxxxxxxx" );
519 res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
520 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
521 ok( val_count == 0, "val_count set to %d\n", val_count );
522 ok( data_count == 7, "data_count set to %d instead of 7\n", data_count );
523 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
524 ok( !strcmp( value, "xxxxxxxxxx" ), "value set to '%s'\n", value );
525 /* v5.1.2600.0 (XP Home and Professional) does not touch data in this case */
526 ok( !strcmp( data, "foobar" ) || !strcmp( data, "xxxxxxx" ),
527 "data set to '%s' instead of 'foobar' or 'xxxxxxx'\n", data );
528
529 /* overflow data */
530 val_count = 20;
531 data_count = 2;
532 type = 1234;
533 strcpy( value, "xxxxxxxxxx" );
534 strcpy( data, "xxxxxxxxxx" );
535 res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
536 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
537 ok( val_count == 20, "val_count set to %d\n", val_count );
538 ok( data_count == 7, "data_count set to %d instead of 7\n", data_count );
539 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
540 ok( !strcmp( value, "xxxxxxxxxx" ), "value set to '%s'\n", value );
541 ok( !strcmp( data, "xxxxxxxxxx" ), "data set to '%s'\n", data );
542
543 /* no overflow */
544 val_count = 20;
545 data_count = 20;
546 type = 1234;
547 strcpy( value, "xxxxxxxxxx" );
548 strcpy( data, "xxxxxxxxxx" );
549 res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
550 ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", res );
551 ok( val_count == 4, "val_count set to %d instead of 4\n", val_count );
552 ok( data_count == 7, "data_count set to %d instead of 7\n", data_count );
553 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
554 ok( !strcmp( value, "Test" ), "value is '%s' instead of Test\n", value );
555 ok( !strcmp( data, "foobar" ), "data is '%s' instead of foobar\n", data );
556
557 /* Unicode tests */
558
559 SetLastError(0xdeadbeef);
560 res = RegSetValueExW( test_key, testW, 0, REG_SZ, (const BYTE *)foobarW, 7*sizeof(WCHAR) );
561 if (res==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
562 {
563 win_skip("RegSetValueExW is not implemented\n");
564 goto cleanup;
565 }
566 ok( res == 0, "RegSetValueExW failed error %d\n", res );
567
568 /* overflow both name and data */
569 val_count = 2;
570 data_count = 2;
571 type = 1234;
572 memcpy( valueW, xxxW, sizeof(xxxW) );
573 memcpy( dataW, xxxW, sizeof(xxxW) );
574 res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
575 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
576 ok( val_count == 2, "val_count set to %d\n", val_count );
577 ok( data_count == 7*sizeof(WCHAR), "data_count set to %d instead of 7*sizeof(WCHAR)\n", data_count );
578 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
579 ok( !memcmp( valueW, xxxW, sizeof(xxxW) ), "value modified\n" );
580 ok( !memcmp( dataW, xxxW, sizeof(xxxW) ), "data modified\n" );
581
582 /* overflow name */
583 val_count = 3;
584 data_count = 20;
585 type = 1234;
586 memcpy( valueW, xxxW, sizeof(xxxW) );
587 memcpy( dataW, xxxW, sizeof(xxxW) );
588 res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
589 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
590 ok( val_count == 3, "val_count set to %d\n", val_count );
591 ok( data_count == 7*sizeof(WCHAR), "data_count set to %d instead of 7*sizeof(WCHAR)\n", data_count );
592 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
593 ok( !memcmp( valueW, xxxW, sizeof(xxxW) ), "value modified\n" );
594 ok( !memcmp( dataW, xxxW, sizeof(xxxW) ), "data modified\n" );
595
596 /* overflow data */
597 val_count = 20;
598 data_count = 2;
599 type = 1234;
600 memcpy( valueW, xxxW, sizeof(xxxW) );
601 memcpy( dataW, xxxW, sizeof(xxxW) );
602 res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
603 ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %d\n", res );
604 ok( val_count == 4, "val_count set to %d instead of 4\n", val_count );
605 ok( data_count == 7*sizeof(WCHAR), "data_count set to %d instead of 7*sizeof(WCHAR)\n", data_count );
606 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
607 ok( !memcmp( valueW, testW, sizeof(testW) ), "value is not 'Test'\n" );
608 ok( !memcmp( dataW, xxxW, sizeof(xxxW) ), "data modified\n" );
609
610 /* no overflow */
611 val_count = 20;
612 data_count = 20;
613 type = 1234;
614 memcpy( valueW, xxxW, sizeof(xxxW) );
615 memcpy( dataW, xxxW, sizeof(xxxW) );
616 res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
617 ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", res );
618 ok( val_count == 4, "val_count set to %d instead of 4\n", val_count );
619 ok( data_count == 7*sizeof(WCHAR), "data_count set to %d instead of 7*sizeof(WCHAR)\n", data_count );
620 ok( type == REG_SZ, "type %d is not REG_SZ\n", type );
621 ok( !memcmp( valueW, testW, sizeof(testW) ), "value is not 'Test'\n" );
622 ok( !memcmp( dataW, foobarW, sizeof(foobarW) ), "data is not 'foobar'\n" );
623
624 cleanup:
625 RegDeleteKeyA(test_key, "");
626 RegCloseKey(test_key);
627 }
628
629 static void test_query_value_ex(void)
630 {
631 DWORD ret;
632 DWORD size;
633 DWORD type;
634 BYTE buffer[10];
635
636 ret = RegQueryValueExA(hkey_main, "TP1_SZ", NULL, &type, NULL, &size);
637 ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", ret);
638 ok(size == strlen(sTestpath1) + 1, "(%d,%d)\n", (DWORD)strlen(sTestpath1) + 1, size);
639 ok(type == REG_SZ, "type %d is not REG_SZ\n", type);
640
641 type = 0xdeadbeef;
642 size = 0xdeadbeef;
643 ret = RegQueryValueExA(HKEY_CLASSES_ROOT, "Nonexistent Value", NULL, &type, NULL, &size);
644 ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %d\n", ret);
645 /* the type parameter is cleared on Win9x, but is set to a random value on
646 * NT, so don't do that test there. The size parameter is left untouched on Win9x
647 * but cleared on NT+, this can be tested on all platforms.
648 */
649 if (GetVersion() & 0x80000000)
650 {
651 ok(type == 0, "type should have been set to 0 instead of 0x%x\n", type);
652 ok(size == 0xdeadbeef, "size should have been left untouched (0xdeadbeef)\n");
653 }
654 else
655 {
656 trace("test_query_value_ex: type set to: 0x%08x\n", type);
657 ok(size == 0, "size should have been set to 0 instead of %d\n", size);
658 }
659
660 size = sizeof(buffer);
661 ret = RegQueryValueExA(HKEY_CLASSES_ROOT, "Nonexistent Value", NULL, &type, buffer, &size);
662 ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %d\n", ret);
663 ok(size == sizeof(buffer), "size shouldn't have been changed to %d\n", size);
664
665 size = 4;
666 ret = RegQueryValueExA(hkey_main, "BIN32", NULL, &size, buffer, &size);
667 ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", ret);
668 }
669
670 static void test_get_value(void)
671 {
672 DWORD ret;
673 DWORD size;
674 DWORD type;
675 DWORD dw, qw[2];
676 CHAR buf[80];
677 CHAR expanded[] = "bar\\subdir1";
678 CHAR expanded2[] = "ImARatherLongButIndeedNeededString\\subdir1";
679
680 if(!pRegGetValueA)
681 {
682 win_skip("RegGetValue not available on this platform\n");
683 return;
684 }
685
686 /* Invalid parameter */
687 ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD, &type, &dw, NULL);
688 ok(ret == ERROR_INVALID_PARAMETER, "ret=%d\n", ret);
689
690 /* Query REG_DWORD using RRF_RT_REG_DWORD (ok) */
691 size = type = dw = 0xdeadbeef;
692 ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD, &type, &dw, &size);
693 ok(ret == ERROR_SUCCESS, "ret=%d\n", ret);
694 ok(size == 4, "size=%d\n", size);
695 ok(type == REG_DWORD, "type=%d\n", type);
696 ok(dw == 0x12345678, "dw=%d\n", dw);
697
698 /* Query by subkey-name */
699 ret = pRegGetValueA(HKEY_CURRENT_USER, "Software\\Wine\\Test", "DWORD", RRF_RT_REG_DWORD, NULL, NULL, NULL);
700 ok(ret == ERROR_SUCCESS, "ret=%d\n", ret);
701
702 /* Query REG_DWORD using RRF_RT_REG_BINARY (restricted) */
703 size = type = dw = 0xdeadbeef;
704 ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_BINARY, &type, &dw, &size);
705 ok(ret == ERROR_UNSUPPORTED_TYPE, "ret=%d\n", ret);
706 /* Although the function failed all values are retrieved */
707 ok(size == 4, "size=%d\n", size);
708 ok(type == REG_DWORD, "type=%d\n", type);
709 ok(dw == 0x12345678, "dw=%d\n", dw);
710
711 /* Test RRF_ZEROONFAILURE */
712 type = dw = 0xdeadbeef; size = 4;