ReactOS 0.4.15-dev-5672-gf73ac17
RegQueryValueExW.c File Reference
#include "precomp.h"
Include dependency graph for RegQueryValueExW.c:

Go to the source code of this file.

Functions

static DWORD delete_key (HKEY hkey)
 
 START_TEST (RegQueryValueExW)
 

Function Documentation

◆ delete_key()

static DWORD delete_key ( HKEY  hkey)
static

Definition at line 10 of file RegQueryValueExW.c.

11{
13 DWORD ret;
14
15 while (!(ret = RegEnumKeyW(hkey, 0, name, _countof(name))))
16 {
17 HKEY tmp;
18 if (!(ret = RegOpenKeyExW(hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp)))
19 {
20 ret = delete_key(tmp);
21 }
22 if (ret)
23 break;
24 }
26 {
27 RegDeleteKeyW(hkey, L"");
28 ret = 0;
29 }
30 RegCloseKey(hkey);
31 return ret;
32}
#define RegCloseKey(hKey)
Definition: registry.h:47
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3356
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1237
LONG WINAPI RegEnumKeyW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cbName)
Definition: reg.c:2416
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define MAX_PATH
Definition: compat.h:34
unsigned long DWORD
Definition: ntddk_ex.h:95
#define KEY_ENUMERATE_SUB_KEYS
Definition: nt_native.h:1019
#define L(x)
Definition: ntvdm.h:50
#define delete_key(r, p, s)
Definition: reg_test.h:64
#define _countof(array)
Definition: sndvol32.h:68
Definition: name.c:39
int ret
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ START_TEST()

START_TEST ( RegQueryValueExW  )

Definition at line 34 of file RegQueryValueExW.c.

35{
37 HKEY subkey;
39 const WCHAR string1W[] = L"1";
40 const WCHAR string22W[] = L"Thisstringhas22letters";
41 WCHAR data22[22];
42 WCHAR data23[23];
43 WCHAR data24[24];
44
45
46 /* If the tree key already exist, delete it to ensure proper testing*/
47 if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\advapi32_apitest", 0, KEY_ALL_ACCESS, &hkey_main) == ERROR_SUCCESS)
49
50 /* Ready to recreate it */
51 SetLastError(0xdeadbeef);
52 ret = RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\advapi32_apitest", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey_main, NULL);
53 ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %lu\n", ret);
54 ok(GetLastError(), "RegCreateKeyExW failed: %lx\n", GetLastError());
55 if(ret != ERROR_SUCCESS)
56 {
57 trace("Unable to create test key, aborting!\n");
58 return;
59 }
60
61 SetLastError(0xdeadbeef);
62 ret = RegCreateKeyExW(hkey_main, L"subkey", 0, L"subkey class", 0, KEY_ALL_ACCESS, NULL, &subkey, NULL);
63 ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %lu\n", ret);
64 ok(GetLastError(), "RegCreateKeyExW failed: %lx\n", GetLastError());
65
66 /* All NULL */
67 SetLastError(0xdeadbeef);
69 ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
70 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
71
72 /* All NULL. Reserved not NULL */
73 type = 666;
74 size = 666;
75 reserved = 3;
76 SetLastError(0xdeadbeef);
78 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
79 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
80 ok(reserved == 3, "Expected reserved=3, reserved is: %ld\n", reserved);
81
82 /* NULL handle. NULL value. Reserved not NULL */
83 type = 666;
84 size = 666;
85 reserved = 3;
86 SetLastError(0xdeadbeef);
88 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
89 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
90 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
91 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
92 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
93
94 /* NULL handle. NULL value */
95 type = 666;
96 size = 666;
97 SetLastError(0xdeadbeef);
99 ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
100 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
101 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
102 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
103
104 /* NULL handle . Inexistent value. Reserved not NULL */
105 type = 666;
106 size = 666;
107 reserved = 3;
108 SetLastError(0xdeadbeef);
109 ret = RegQueryValueExW(NULL, L"MSITESTVAR11", &reserved, &type, NULL, &size);
110 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
111 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
112 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
113 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
114 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
115
116 /* NULL handle . Inexistent value. */
117 type = 666;
118 size = 666;
119 SetLastError(0xdeadbeef);
120 ret = RegQueryValueExW(NULL, L"MSITESTVAR11", NULL, &type, NULL, &size);
121 ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
122 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
123 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
124 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
125
126 /* NULL handle */
127 type = 666;
128 size = 666;
129 SetLastError(0xdeadbeef);
130 ret = RegQueryValueExW(NULL, L"MSITESTVAR11", NULL, &type, NULL, &size);
131 ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
132 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
133 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
134 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
135
136 /* INVALID handle. NULL value. Reserved not NULL */
137 type = 666;
138 size = 666;
139 reserved = 3;
140 SetLastError(0xdeadbeef);
142 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
143 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
144 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
145 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
146 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
147
148 /* INVALID handle. NULL value.*/
149 type = 666;
150 size = 666;
151 SetLastError(0xdeadbeef);
153 ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
154 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
155 ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
156 ok(size == 0, "Expected size = 0, size is: %ld\n", size);
157 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
158
159 /* INVALID handle. Non-existent value. Reserved not NULL*/
160 type = 666;
161 size = 666;
162 reserved = 3;
163 SetLastError(0xdeadbeef);
164 ret = RegQueryValueExW((HKEY)-4, L"MSITESTVAR11", &reserved, &type, NULL, &size);
165 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
166 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
167 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
168 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
169 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
170
171 /* INVALID handle. Non-existent value. */
172 type = 666;
173 size = 666;
174 SetLastError(0xdeadbeef);
175 ret = RegQueryValueExW((HKEY)-4, L"MSITESTVAR11", NULL, &type, NULL, &size);
176 ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
177 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
178 ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
179 ok(size == 0, "Expected size = 0, size is: %ld\n", size);
180
181 /* VALID handle, Non-existent value, Reserved not NULL */
182 type = 666;
183 size = 666;
184 reserved = 3;
185 SetLastError(0xdeadbeef);
186 ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", &reserved, &type, NULL, &size);
187 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
188 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
189 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
190 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
191 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
192
193 /* VALID handle, Non-existent value */
194 type = 666;
195 size = 666;
196 SetLastError(0xdeadbeef);
197 ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", NULL, &type, NULL, &size);
198 ok(ret == ERROR_FILE_NOT_FOUND, "RegQueryValueExW returned: %lx\n", ret);
199 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
200 ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
201 ok(size == 0, "Expected size = 0, size is: %ld\n", size);
202
203 /* VALID handle, NULL value */
204 type = 666;
205 size = 666;
206 SetLastError(0xdeadbeef);
208 ok(ret == ERROR_FILE_NOT_FOUND, "RegQueryValueExW returned: %lx\n", ret);
209 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
210 ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
211 ok(size == 0, "Expected size = 0, size is: %ld\n", size);
212
213 /* Create the value */
214 SetLastError(0xdeadbeef);
215 if ((ret = RegSetValueExW(hkey_main, L"MSITESTVAR11", 0, REG_NONE, (const BYTE *)string1W, 4)) != ERROR_SUCCESS)
216 {
217 ok(1, "RegSetValueExW failed: %lx, %lx\n", ret, GetLastError());
218 }
219 if ((ret = RegSetValueExW(hkey_main, L"LONGSTRING", 0, REG_SZ, (const BYTE *)string22W, (lstrlenW(string22W)+1) * sizeof(WCHAR))) != ERROR_SUCCESS)
220 {
221 ok(1, "RegSetValueExW failed: %lx, %lx\n", ret, GetLastError());
222 }
223
224 /* Existent value. Reserved not NULL */
225 SetLastError(0xdeadbeef);
226 size = 666;
227 type = 666;
228 reserved = 3;
229 ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", &reserved, &type, NULL, &size);
230 ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
231 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
232 ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
233 ok(size == 666, "Expected untouched, Size was set with: %ld\n", size);
234 ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
235
236 /* Existent value */
237 SetLastError(0xdeadbeef);
238 size = 666;
239 type = 666;
240 ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", NULL, &type, NULL, &size);
241 ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
242 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
243 ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
244 ok(size == 4, "Expected size = 4, size is: %ld\n", size);
245
246 /* Data tests */
247 /* Buffer one wchar smaller than needed */
248 SetLastError(0xdeadbeef);
249 size = sizeof(data22);
250 type = 666;
251 ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data22, &size);
252 ok(ret == ERROR_MORE_DATA, "RegQueryValueExW returned: %lx\n", ret);
253 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
254 ok(type == REG_SZ, "Expected REG_SZ, Type is: %ld\n", type);
255 ok(size == 46, "Expected size = 46, size is: %ld\n", size);
256 ok(wcscmp(data22, string22W), "Expected being different!");
257
258 /* Buffer has perfect size */
259 SetLastError(0xdeadbeef);
260 size = sizeof(data23);
261 type = 666;
262 ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data23, &size);
263 ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
264 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
265 ok(type == REG_SZ, "Expected REG_SZ, Type is: %ld\n", type);
266 ok(size == 46, "Expected size = 46, size is: %ld", size);
267 ok(!wcscmp(data23,string22W), "Expected same string! data23: %S, string22W: %S", data23, string22W);
268
269 /* Buffer one wchar bigger than needed */
270 SetLastError(0xdeadbeef);
271 size = sizeof(data24);
272 type = 666;
273 ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data24, &size);
274 ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
275 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
276 ok(type == REG_SZ, "Expected REG_SZ, Type is: %ld\n", type);
277 ok(size == 46, "Expected size = 46, size is: %ld\n", size);
278 ok(!wcscmp(data24, string22W), "Expected same string! data24: %S, string22W: %S\n", data24, string22W);
279
280 /* Buffer has perfect size. Size wrong: 1 WCHAR less */
281 SetLastError(0xdeadbeef);
282 memset(data23, 0, sizeof(data23));
283 size = sizeof(data23) - 2;
284 type = 666;
285 ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data23, &size);
286 ok(ret == ERROR_MORE_DATA, "RegQueryValueExW returned: %lx\n", ret);
287 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
288 ok(type == REG_SZ, "Expected REG_SZ, Type is: %ld\n", type);
289 ok(size == 46, "Expected size = 46, size is: %ld", size);
290 ok(wcscmp(data23, string22W), "Expected different string!\n");
291
292 /* Buffer has perfect size. Size wrong: 1 WCHAR more */
293 SetLastError(0xdeadbeef);
294 memset(data23, 0, sizeof(data23));
295 size = sizeof(data23) + 2;
296 type = 666;
297 ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data23, &size);
298 ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
299 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
300 ok(type == REG_SZ, "Expected REG_SZ, Type is: %ld\n", type);
301 ok(size == 46, "Expected size = 46, size is: %ld", size);
302 ok(!wcscmp(data23, string22W), "Expected same string! data23: %S, string22W: %S", data23, string22W);
303
304 /* Ask for a var that doesnt exist. */
305 SetLastError(0xdeadbeef);
306 size = sizeof(data23);
307 memset(data23, 0, sizeof(data23));
308 type = 666;
309 ret = RegQueryValueExW(hkey_main, L"XXXXXYYYYYZZZZZZ", NULL, &type, (LPBYTE)data23, &size);
310 ok(ret == ERROR_FILE_NOT_FOUND, "RegQueryValueExW returned: %lx\n", ret);
311 ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
312 /* 2k3 leaves garbage */
313 ok(type == REG_NONE || broken(type != REG_NONE && type != 666), "Expected REG_NONE, Type is: %ld\n", type);
314 ok(size == 46, "Expected size = 46, size is: %ld", size);
315 ok(!wcscmp(data23,L""), "Expected same string! data23: %S, ''", data23);
316
317
319 RegCloseKey(subkey);
320
321 /* Delete the whole test key */
322 RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\ReactOS\\advapi32_apitest", &hkey_main);
324}
#define broken(x)
Definition: _sntprintf.h:21
#define trace
Definition: atltest.h:70
#define ok(value,...)
Definition: atltest.h:57
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1091
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3291
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4900
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4121
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define lstrlenW
Definition: compat.h:750
r reserved
Definition: btrfs.c:3006
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
#define REG_SZ
Definition: layer.c:22
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static HKEY hkey_main
Definition: registry.c:37
static BYTE data22[]
Definition: misc.c:525
static BYTE data24[]
Definition: misc.c:527
static BYTE data23[]
Definition: misc.c:526
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define REG_NONE
Definition: nt_native.h:1492
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define memset(x, y, z)
Definition: compat.h:39
unsigned char * LPBYTE
Definition: typedefs.h:53
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
#define HKEY_CURRENT_USER
Definition: winreg.h:11
unsigned char BYTE
Definition: xxhash.c:193