dlls/advapi32/tests/registry.c

   1 /*
   2  * Unit tests for registry functions
   3  *
   4  * Copyright (c) 2002 Alexandre Julliard
   5  * Copyright (c) 2010 André Hentschel
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "wine/test.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winternl.h"
  31 #include "winreg.h"
  32 #include "winperf.h"
  33 #include "winsvc.h"
  34 #include "winerror.h"
  35 #include "aclapi.h"
  36
  37 #define IS_HKCR(hk) ((UINT_PTR)hk > 0 && ((UINT_PTR)hk & 3) == 2)
  38
  39 static HKEY hkey_main;
  40 static DWORD GLE;
  41
  42 static const char * sTestpath1 = "%LONGSYSTEMVAR%\\subdir1";
  43 static const char * sTestpath2 = "%FOO%\\subdir1";
  44 static const DWORD ptr_size = 8 * sizeof(void*);
  45
  46 static DWORD (WINAPI *pRegGetValueA)(HKEY,LPCSTR,LPCSTR,DWORD,LPDWORD,PVOID,LPDWORD);
  47 static DWORD (WINAPI *pRegGetValueW)(HKEY,LPCWSTR,LPCWSTR,DWORD,LPDWORD,PVOID,LPDWORD);
  48 static LONG (WINAPI *pRegCopyTreeA)(HKEY,const char *,HKEY);
  49 static LONG (WINAPI *pRegDeleteTreeA)(HKEY,const char *);
  50 static DWORD (WINAPI *pRegDeleteKeyExA)(HKEY,LPCSTR,REGSAM,DWORD);
  51 static BOOL (WINAPI *pIsWow64Process)(HANDLE,PBOOL);
  52 static NTSTATUS (WINAPI * pNtDeleteKey)(HANDLE);
  53 static NTSTATUS (WINAPI * pNtUnloadKey)(POBJECT_ATTRIBUTES);
  54 static NTSTATUS (WINAPI * pRtlFormatCurrentUserKeyPath)(UNICODE_STRING*);
  55 static NTSTATUS (WINAPI * pRtlFreeUnicodeString)(PUNICODE_STRING);
  56 static NTSTATUS (WINAPI * pRtlInitUnicodeString)(PUNICODE_STRING,PCWSTR);
  57 static LONG (WINAPI *pRegDeleteKeyValueA)(HKEY,LPCSTR,LPCSTR);
  58 static LONG (WINAPI *pRegSetKeyValueW)(HKEY,LPCWSTR,LPCWSTR,DWORD,const void*,DWORD);
  59 static LONG (WINAPI *pRegLoadMUIStringA)(HKEY,LPCSTR,LPSTR,DWORD,LPDWORD,DWORD,LPCSTR);
  60 static LONG (WINAPI *pRegLoadMUIStringW)(HKEY,LPCWSTR,LPWSTR,DWORD,LPDWORD,DWORD,LPCWSTR);
  61 static DWORD (WINAPI *pEnumDynamicTimeZoneInformation)(const DWORD,
  62                                                        DYNAMIC_TIME_ZONE_INFORMATION*);
  63
  64 static BOOL limited_user;
  65 static const BOOL is_64bit = sizeof(void *) > sizeof(int);
  66
  67 static BOOL has_wow64(void)
  68 {
  69     if (!is_64bit)
  70     {
  71         BOOL is_wow64;
  72         if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 ) || !is_wow64)
  73             return FALSE;
  74     }
  75     return TRUE;
  76 }
  77
  78 static const char *dbgstr_SYSTEMTIME(const SYSTEMTIME *st)
  79 {
  80     return wine_dbg_sprintf("%02d-%02d-%04d %02d:%02d:%02d.%03d",
  81                             st->wMonth, st->wDay, st->wYear,
  82                             st->wHour, st->wMinute, st->wSecond, st->wMilliseconds);
  83 }
  84
  85 #define ADVAPI32_GET_PROC(func) \
  86     p ## func = (void*)GetProcAddress(hadvapi32, #func)
  87
  88 static void InitFunctionPtrs(void)
  89 {
  90     HMODULE hntdll = GetModuleHandleA("ntdll.dll");
  91     HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
  92     HMODULE hadvapi32 = GetModuleHandleA("advapi32.dll");
  93
  94     /* This function was introduced with Windows 2003 SP1 */
  95     ADVAPI32_GET_PROC(RegGetValueA);
  96     ADVAPI32_GET_PROC(RegGetValueW);
  97     ADVAPI32_GET_PROC(RegCopyTreeA);
  98     ADVAPI32_GET_PROC(RegDeleteTreeA);
  99     ADVAPI32_GET_PROC(RegDeleteKeyExA);
 100     ADVAPI32_GET_PROC(RegDeleteKeyValueA);
 101     ADVAPI32_GET_PROC(RegSetKeyValueW);
 102     ADVAPI32_GET_PROC(RegLoadMUIStringA);
 103     ADVAPI32_GET_PROC(RegLoadMUIStringW);
 104     ADVAPI32_GET_PROC(EnumDynamicTimeZoneInformation);
 105
 106     pIsWow64Process = (void *)GetProcAddress( hkernel32, "IsWow64Process" );
 107     pRtlFormatCurrentUserKeyPath = (void *)GetProcAddress( hntdll, "RtlFormatCurrentUserKeyPath" );
 108     pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
 109     pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
 110     pNtDeleteKey = (void *)GetProcAddress( hntdll, "NtDeleteKey" );
 111     pNtUnloadKey = (void *)GetProcAddress( hntdll, "NtUnloadKey" );
 112 }
 113
 114 static BOOL is_special_key(HKEY key)
 115 {
 116     return !!((ULONG_PTR)key & 0x80000000);
 117 }
 118
 119 /* delete key and all its subkeys */
 120 static DWORD delete_key( HKEY hkey )
 121 {
 122     char name[MAX_PATH];
 123     DWORD ret;
 124
 125     if ((ret = RegOpenKeyExA( hkey, "", 0, KEY_ENUMERATE_SUB_KEYS, &hkey ))) return ret;
 126     while (!(ret = RegEnumKeyA(hkey, 0, name, sizeof(name))))
 127     {
 128         HKEY tmp;
 129         if (!(ret = RegOpenKeyExA( hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp )))
 130         {
 131             ret = delete_key( tmp );
 132             RegCloseKey( tmp );
 133         }
 134         if (ret) break;
 135     }
 136     if (ret != ERROR_NO_MORE_ITEMS) return ret;
 137     RegDeleteKeyA( hkey, "" );
 138     RegCloseKey(hkey);
 139     return 0;
 140 }
 141
 142 static void setup_main_key(void)
 143 {
 144     DWORD ret;
 145
 146     if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkey_main )) delete_key( hkey_main );
 147
 148     ret = RegCreateKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkey_main );
 149     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
 150 }
 151
 152 static void check_user_privs(void)
 153 {
 154     DWORD ret;
 155     HKEY hkey = (HKEY)0xdeadbeef;
 156
 157     ret = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software", 0, KEY_READ|KEY_WRITE, &hkey);
 158     ok(ret == ERROR_SUCCESS || ret == ERROR_ACCESS_DENIED, "expected success or access denied, got %li\n", ret);
 159     if (ret == ERROR_SUCCESS)
 160     {
 161         ok(hkey != NULL, "RegOpenKeyExA succeeded but returned NULL hkey\n");
 162         RegCloseKey(hkey);
 163     }
 164     else
 165     {
 166         ok(hkey == NULL, "RegOpenKeyExA failed but returned hkey %p\n", hkey);
 167         limited_user = TRUE;
 168         trace("running as limited user\n");
 169     }
 170 }
 171
 172 #define lok ok_(__FILE__, line)
 173 #define test_hkey_main_Value_A(name, string, full_byte_len) _test_hkey_main_Value_A(__LINE__, name, string, full_byte_len)
 174 static void _test_hkey_main_Value_A(int line, LPCSTR name, LPCSTR string,
 175                                    DWORD full_byte_len)
 176 {
 177     DWORD ret, type, cbData;
 178     DWORD str_byte_len;
 179     BYTE* value;
 180
 181     type=0xdeadbeef;
 182     cbData=0xdeadbeef;
 183     /* When successful RegQueryValueExA() leaves GLE as is,
 184      * so we must reset it to detect unimplemented functions.
 185      */
 186     SetLastError(0xdeadbeef);
 187     ret = RegQueryValueExA(hkey_main, name, NULL, &type, NULL, &cbData);
 188     GLE = GetLastError();
 189     lok(ret == ERROR_SUCCESS, "RegQueryValueExA/1 failed: %ld, GLE=%ld\n", ret, GLE);
 190     /* It is wrong for the Ansi version to not be implemented */
 191     ok(GLE == 0xdeadbeef, "RegQueryValueExA set GLE = %lu\n", GLE);
 192     if(GLE == ERROR_CALL_NOT_IMPLEMENTED) return;
 193
 194     str_byte_len = (string ? lstrlenA(string) : 0) + 1;
 195     lok(type == REG_SZ, "RegQueryValueExA/1 returned type %ld\n", type);
 196     lok(cbData == full_byte_len, "cbData=%ld instead of %ld or %ld\n", cbData, full_byte_len, str_byte_len);
 197
 198     value = malloc(cbData+1);
 199     memset(value, 0xbd, cbData+1);
 200     type=0xdeadbeef;
 201     ret = RegQueryValueExA(hkey_main, name, NULL, &type, value, &cbData);
 202     GLE = GetLastError();
 203     lok(ret == ERROR_SUCCESS, "RegQueryValueExA/2 failed: %ld, GLE=%ld\n", ret, GLE);
 204     if (!string)
 205     {
 206         /* When cbData == 0, RegQueryValueExA() should not modify the buffer */
 207         lok(*value == 0xbd, "RegQueryValueExA overflowed: cbData=%lu *value=%02x\n", cbData, *value);
 208     }
 209     else
 210     {
 211         lok(memcmp(value, string, cbData) == 0, "RegQueryValueExA/2 failed: %s/%ld != %s/%ld\n",
 212            debugstr_an((char*)value, cbData), cbData,
 213            debugstr_an(string, full_byte_len), full_byte_len);
 214         lok(*(value+cbData) == 0xbd, "RegQueryValueExA/2 overflowed at offset %lu: %02x != bd\n", cbData, *(value+cbData));
 215     }
 216     free(value);
 217 }
 218
 219 #define test_hkey_main_Value_W(name, string, full_byte_len) _test_hkey_main_Value_W(__LINE__, name, string, full_byte_len)
 220 static void _test_hkey_main_Value_W(int line, LPCWSTR name, LPCWSTR string,
 221                                    DWORD full_byte_len)
 222 {
 223     DWORD ret, type, cbData;
 224     BYTE* value;
 225
 226     type=0xdeadbeef;
 227     cbData=0xdeadbeef;
 228     /* When successful RegQueryValueExW() leaves GLE as is,
 229      * so we must reset it to detect unimplemented functions.
 230      */
 231     SetLastError(0xdeadbeef);
 232     ret = RegQueryValueExW(hkey_main, name, NULL, &type, NULL, &cbData);
 233     GLE = GetLastError();
 234     lok(ret == ERROR_SUCCESS, "RegQueryValueExW/1 failed: %ld, GLE=%ld\n", ret, GLE);
 235     if(GLE == ERROR_CALL_NOT_IMPLEMENTED)
 236     {
 237         win_skip("RegQueryValueExW() is not implemented\n");
 238         return;
 239     }
 240
 241     lok(type == REG_SZ, "RegQueryValueExW/1 returned type %ld\n", type);
 242     lok(cbData == full_byte_len,
 243         "cbData=%ld instead of %ld\n", cbData, full_byte_len);
 244
 245     /* Give enough space to overflow by one WCHAR */
 246     value = malloc(cbData+2);
 247     memset(value, 0xbd, cbData+2);
 248     type=0xdeadbeef;
 249     ret = RegQueryValueExW(hkey_main, name, NULL, &type, value, &cbData);
 250     GLE = GetLastError();
 251     lok(ret == ERROR_SUCCESS, "RegQueryValueExW/2 failed: %ld, GLE=%ld\n", ret, GLE);
 252     if (string)
 253     {
 254         lok(memcmp(value, string, cbData) == 0, "RegQueryValueExW failed: %s/%ld != %s/%ld\n",
 255            wine_dbgstr_wn((WCHAR*)value, cbData / sizeof(WCHAR)), cbData,
 256            wine_dbgstr_wn(string, full_byte_len / sizeof(WCHAR)), full_byte_len);
 257     }
 258     /* This implies that when cbData == 0, RegQueryValueExW() should not modify the buffer */
 259     lok(*(value+cbData) == 0xbd, "RegQueryValueExW/2 overflowed at %lu: %02x != bd\n", cbData, *(value+cbData));
 260     lok(*(value+cbData+1) == 0xbd, "RegQueryValueExW/2 overflowed at %lu+1: %02x != bd\n", cbData, *(value+cbData+1));
 261     free(value);
 262 }
 263
 264 static void test_set_value(void)
 265 {
 266     DWORD ret;
 267
 268     static const WCHAR name1W[] =   L"CleanSingleString";
 269     static const WCHAR name2W[] =   L"SomeIntraZeroedString";
 270     static const WCHAR emptyW[] =   L"";
 271     static const WCHAR string1W[] = L"ThisNeverBreaks";
 272     static const WCHAR string2W[] = L"This\0Breaks\0\0A\0\0\0Lot\0\0\0\0";
 273     static const WCHAR substring2W[] = L"This";
 274
 275     static const char name1A[] =   "CleanSingleString";
 276     static const char name2A[] =   "SomeIntraZeroedString";
 277     static const char emptyA[] = "";
 278     static const char string1A[] = "ThisNeverBreaks";
 279     static const char string2A[] = "This\0Breaks\0\0A\0\0\0Lot\0\0\0\0";
 280     static const char substring2A[] = "This";
 281
 282     ret = RegSetValueA(hkey_main, NULL, REG_SZ, NULL, 0);
 283     ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueA should have failed with ERROR_INVALID_PARAMETER instead of %ld\n", ret);
 284
 285     ret = RegSetValueA(hkey_main, NULL, REG_SZ, string1A, sizeof(string1A));
 286     ok(ret == ERROR_SUCCESS, "RegSetValueA failed: %ld, GLE=%ld\n", ret, GetLastError());
 287     test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
 288     test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
 289
 290     /* RegSetValueA ignores the size passed in */
 291     ret = RegSetValueA(hkey_main, NULL, REG_SZ, string1A, 4);
 292     ok(ret == ERROR_SUCCESS, "RegSetValueA failed: %ld, GLE=%ld\n", ret, GetLastError());
 293     test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
 294     test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
 295
 296     /* stops at first null */
 297     ret = RegSetValueA(hkey_main, NULL, REG_SZ, string2A, sizeof(string2A));
 298     ok(ret == ERROR_SUCCESS, "RegSetValueA failed: %ld, GLE=%ld\n", ret, GetLastError());
 299     test_hkey_main_Value_A(NULL, substring2A, sizeof(substring2A));
 300     test_hkey_main_Value_W(NULL, substring2W, sizeof(substring2W));
 301
 302     /* only REG_SZ is supported on NT*/
 303     ret = RegSetValueA(hkey_main, NULL, REG_BINARY, string2A, sizeof(string2A));
 304     ok(ret == ERROR_INVALID_PARAMETER, "got %ld (expected ERROR_INVALID_PARAMETER)\n", ret);
 305
 306     ret = RegSetValueA(hkey_main, NULL, REG_EXPAND_SZ, string2A, sizeof(string2A));
 307     ok(ret == ERROR_INVALID_PARAMETER, "got %ld (expected ERROR_INVALID_PARAMETER)\n", ret);
 308
 309     ret = RegSetValueA(hkey_main, NULL, REG_MULTI_SZ, string2A, sizeof(string2A));
 310     ok(ret == ERROR_INVALID_PARAMETER, "got %ld (expected ERROR_INVALID_PARAMETER)\n", ret);
 311
 312     /* Test RegSetValueExA with a 'zero-byte' string (as Office 2003 does).
 313      * Surprisingly enough we're supposed to get zero bytes out of it.
 314      */
 315     ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)emptyA, 0);
 316     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%ld\n", ret, GetLastError());
 317     test_hkey_main_Value_A(name1A, NULL, 0);
 318     test_hkey_main_Value_W(name1W, NULL, 0);
 319
 320     /* test RegSetValueExA with an empty string */
 321     ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)emptyA, sizeof(emptyA));
 322     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%ld\n", ret, GetLastError());
 323     test_hkey_main_Value_A(name1A, emptyA, sizeof(emptyA));
 324     test_hkey_main_Value_W(name1W, emptyW, sizeof(emptyW));
 325
 326     /* test RegSetValueExA with off-by-one size */
 327     ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)string1A, sizeof(string1A)-sizeof(string1A[0]));
 328     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%ld\n", ret, GetLastError());
 329     test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
 330     test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
 331
 332     /* test RegSetValueExA with normal string */
 333     ret = RegSetValueExA(hkey_main, name1A, 0, REG_SZ, (const BYTE *)string1A, sizeof(string1A));
 334     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%ld\n", ret, GetLastError());
 335     test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
 336     test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
 337
 338     /* test RegSetValueExA with intrazeroed string */
 339     ret = RegSetValueExA(hkey_main, name2A, 0, REG_SZ, (const BYTE *)string2A, sizeof(string2A));
 340     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%ld\n", ret, GetLastError());
 341     test_hkey_main_Value_A(name2A, string2A, sizeof(string2A));
 342     test_hkey_main_Value_W(name2W, string2W, sizeof(string2W));
 343
 344     if (0)
 345     {
 346         ret = RegSetValueW(hkey_main, NULL, REG_SZ, NULL, 0);
 347         ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have failed with ERROR_INVALID_PARAMETER instead of %ld\n", ret);
 348
 349         RegSetValueExA(hkey_main, name2A, 0, REG_SZ, (const BYTE *)1, 1);
 350         RegSetValueExA(hkey_main, name2A, 0, REG_DWORD, (const BYTE *)1, 1);
 351     }
 352
 353     ret = RegSetValueW(hkey_main, NULL, REG_SZ, string1W, sizeof(string1W));
 354     ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %ld, GLE=%ld\n", ret, GetLastError());
 355     test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
 356     test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
 357
 358     ret = RegSetValueW(hkey_main, name1W, REG_SZ, string1W, sizeof(string1W));
 359     ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %ld, GLE=%ld\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     /* RegSetValueW ignores the size passed in */
 364     ret = RegSetValueW(hkey_main, NULL, REG_SZ, string1W, 4 * sizeof(string1W[0]));
 365     ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %ld, GLE=%ld\n", ret, GetLastError());
 366     test_hkey_main_Value_A(NULL, string1A, sizeof(string1A));
 367     test_hkey_main_Value_W(NULL, string1W, sizeof(string1W));
 368
 369     /* stops at first null */
 370     ret = RegSetValueW(hkey_main, NULL, REG_SZ, string2W, sizeof(string2W));
 371     ok(ret == ERROR_SUCCESS, "RegSetValueW failed: %ld, GLE=%ld\n", ret, GetLastError());
 372     test_hkey_main_Value_A(NULL, substring2A, sizeof(substring2A));
 373     test_hkey_main_Value_W(NULL, substring2W, sizeof(substring2W));
 374
 375     /* only REG_SZ is supported */
 376     ret = RegSetValueW(hkey_main, NULL, REG_BINARY, string2W, sizeof(string2W));
 377     ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have returned ERROR_INVALID_PARAMETER instead of %ld\n", ret);
 378     ret = RegSetValueW(hkey_main, NULL, REG_EXPAND_SZ, string2W, sizeof(string2W));
 379     ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have returned ERROR_INVALID_PARAMETER instead of %ld\n", ret);
 380     ret = RegSetValueW(hkey_main, NULL, REG_MULTI_SZ, string2W, sizeof(string2W));
 381     ok(ret == ERROR_INVALID_PARAMETER, "RegSetValueW should have returned ERROR_INVALID_PARAMETER instead of %ld\n", ret);
 382
 383     /* test RegSetValueExW with off-by-one size */
 384     ret = RegSetValueExW(hkey_main, name1W, 0, REG_SZ, (const BYTE *)string1W, sizeof(string1W)-sizeof(string1W[0]));
 385     ok(ret == ERROR_SUCCESS, "RegSetValueExW failed: %ld, GLE=%ld\n", ret, GetLastError());
 386     test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
 387     test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
 388
 389     /* test RegSetValueExW with normal string */
 390     ret = RegSetValueExW(hkey_main, name1W, 0, REG_SZ, (const BYTE *)string1W, sizeof(string1W));
 391     ok(ret == ERROR_SUCCESS, "RegSetValueExW failed: %ld, GLE=%ld\n", ret, GetLastError());
 392     test_hkey_main_Value_A(name1A, string1A, sizeof(string1A));
 393     test_hkey_main_Value_W(name1W, string1W, sizeof(string1W));
 394
 395     /* test RegSetValueExW with intrazeroed string */
 396     ret = RegSetValueExW(hkey_main, name2W, 0, REG_SZ, (const BYTE *)string2W, sizeof(string2W));
 397     ok(ret == ERROR_SUCCESS, "RegSetValueExW failed: %ld, GLE=%ld\n", ret, GetLastError());
 398     test_hkey_main_Value_A(name2A, string2A, sizeof(string2A));
 399     test_hkey_main_Value_W(name2W, string2W, sizeof(string2W));
 400
 401     /* test RegSetValueExW with data = 1 */
 402     ret = RegSetValueExW(hkey_main, name2W, 0, REG_SZ, (const BYTE *)1, 1);
 403     ok(ret == ERROR_NOACCESS, "RegSetValueExW should have failed with ERROR_NOACCESS: %ld, GLE=%ld\n", ret, GetLastError());
 404     ret = RegSetValueExW(hkey_main, name2W, 0, REG_DWORD, (const BYTE *)1, 1);
 405     ok(ret == ERROR_NOACCESS, "RegSetValueExW should have failed with ERROR_NOACCESS: %ld, GLE=%ld\n", ret, GetLastError());
 406
 407     if (pRegGetValueA) /* avoid a crash on Windows 2000 */
 408     {
 409         ret = RegSetValueExW(hkey_main, NULL, 0, REG_SZ, NULL, 4);
 410         ok(ret == ERROR_NOACCESS, "RegSetValueExW should have failed with ERROR_NOACCESS: %ld, GLE=%ld\n", ret, GetLastError());
 411
 412         ret = RegSetValueExW(hkey_main, NULL, 0, REG_SZ, NULL, 0);
 413         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 414
 415         ret = RegSetValueExW(hkey_main, NULL, 0, REG_DWORD, NULL, 4);
 416         ok(ret == ERROR_NOACCESS, "RegSetValueExW should have failed with ERROR_NOACCESS: %ld, GLE=%ld\n", ret, GetLastError());
 417
 418         ret = RegSetValueExW(hkey_main, NULL, 0, REG_DWORD, NULL, 0);
 419         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 420     }
 421
 422     /* RegSetKeyValue */
 423     if (!pRegSetKeyValueW)
 424         win_skip("RegSetKeyValue() is not supported.\n");
 425     else
 426     {
 427         DWORD len, type;
 428         HKEY subkey;
 429
 430         ret = pRegSetKeyValueW(hkey_main, NULL, name1W, REG_SZ, (const BYTE*)string2W, sizeof(string2W));
 431         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 432         test_hkey_main_Value_A(name1A, string2A, sizeof(string2A));
 433         test_hkey_main_Value_W(name1W, string2W, sizeof(string2W));
 434
 435         ret = pRegSetKeyValueW(hkey_main, L"subkey", name1W, REG_SZ, string1W, sizeof(string1W));
 436         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 437
 438         ret = RegOpenKeyExW(hkey_main, L"subkey", 0, KEY_QUERY_VALUE, &subkey);
 439         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 440         type = len = 0;
 441         ret = RegQueryValueExW(subkey, name1W, 0, &type, NULL, &len);
 442         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 443         ok(len == sizeof(string1W), "got %ld\n", len);
 444         ok(type == REG_SZ, "got type %ld\n", type);
 445
 446         ret = pRegSetKeyValueW(hkey_main, L"subkey", name1W, REG_SZ, NULL, 0);
 447         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
 448
 449         ret = pRegSetKeyValueW(hkey_main, L"subkey", name1W, REG_SZ, NULL, 4);
 450         ok(ret == ERROR_NOACCESS, "got %ld\n", ret);
 451
 452         ret = pRegSetKeyValueW(hkey_main, L"subkey", name1W, REG_DWORD, NULL, 4);
 453         ok(ret == ERROR_NOACCESS, "got %ld\n", ret);
 454
 455         RegCloseKey(subkey);
 456     }
 457 }
 458
 459 static void create_test_entries(void)
 460 {
 461     static const DWORD qw[2] = { 0x12345678, 0x87654321 };
 462
 463     SetEnvironmentVariableA("LONGSYSTEMVAR", "bar");
 464     SetEnvironmentVariableA("FOO", "ImARatherLongButIndeedNeededString");
 465
 466     ok(!RegSetValueExA(hkey_main,"TP1_EXP_SZ",0,REG_EXPAND_SZ, (const BYTE *)sTestpath1, strlen(sTestpath1)+1),
 467         "RegSetValueExA failed\n");
 468     ok(!RegSetValueExA(hkey_main,"TP1_SZ",0,REG_SZ, (const BYTE *)sTestpath1, strlen(sTestpath1)+1),
 469         "RegSetValueExA failed\n");
 470     ok(!RegSetValueExA(hkey_main,"TP1_ZB_SZ",0,REG_SZ, (const BYTE *)"", 0),
 471        "RegSetValueExA failed\n");
 472     ok(!RegSetValueExA(hkey_main,"TP2_EXP_SZ",0,REG_EXPAND_SZ, (const BYTE *)sTestpath2, strlen(sTestpath2)+1),
 473         "RegSetValueExA failed\n");
 474     ok(!RegSetValueExA(hkey_main,"DWORD",0,REG_DWORD, (const BYTE *)qw, 4),
 475         "RegSetValueExA failed\n");
 476     ok(!RegSetValueExA(hkey_main,"BIN32",0,REG_BINARY, (const BYTE *)qw, 4),
 477         "RegSetValueExA failed\n");
 478     ok(!RegSetValueExA(hkey_main,"BIN64",0,REG_BINARY, (const BYTE *)qw, 8),
 479         "RegSetValueExA failed\n");
 480 }
 481
 482 static void test_enum_value(void)
 483 {
 484     DWORD res;
 485     HKEY test_key;
 486     char value[20], data[30];
 487     WCHAR valueW[20], dataW[20];
 488     DWORD val_count, data_count, type;
 489
 490     /* create the working key for new 'Test' value */
 491     res = RegCreateKeyA( hkey_main, "TestKey", &test_key );
 492     ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res);
 493
 494     /* check NULL data with zero length */
 495     res = RegSetValueExA( test_key, "Test", 0, REG_SZ, NULL, 0 );
 496     if (GetVersion() & 0x80000000)
 497         ok( res == ERROR_INVALID_PARAMETER, "RegSetValueExA returned %ld\n", res );
 498     else
 499         ok( !res, "RegSetValueExA returned %ld\n", res );
 500     res = RegSetValueExA( test_key, "Test", 0, REG_EXPAND_SZ, NULL, 0 );
 501     ok( ERROR_SUCCESS == res, "RegSetValueExA returned %ld\n", res );
 502     res = RegSetValueExA( test_key, "Test", 0, REG_BINARY, NULL, 0 );
 503     ok( ERROR_SUCCESS == res, "RegSetValueExA returned %ld\n", res );
 504
 505     /* test reading the value and data without setting them */
 506     val_count = 20;
 507     data_count = 20;
 508     type = 1234;
 509     strcpy( value, "xxxxxxxxxx" );
 510     strcpy( data, "xxxxxxxxxx" );
 511     res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
 512     ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res );
 513     ok( val_count == 4, "val_count set to %ld instead of 4\n", val_count );
 514     ok( data_count == 0, "data_count set to %ld instead of 0\n", data_count );
 515     ok( type == REG_BINARY, "type %ld is not REG_BINARY\n", type );
 516     ok( !strcmp( value, "Test" ), "value is '%s' instead of Test\n", value );
 517     ok( !strcmp( data, "xxxxxxxxxx" ), "data is '%s' instead of xxxxxxxxxx\n", data );
 518
 519     val_count = 20;
 520     data_count = 20;
 521     type = 1234;
 522     wcscpy( valueW, L"xxxxxxxx" );
 523     wcscpy( dataW, L"xxxxxxxx" );
 524     res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
 525     ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res );
 526     ok( val_count == 4, "val_count set to %ld instead of 4\n", val_count );
 527     ok( data_count == 0, "data_count set to %ld instead of 0\n", data_count );
 528     ok( type == REG_BINARY, "type %ld is not REG_BINARY\n", type );
 529     ok( !wcscmp( valueW, L"Test" ), "value is not 'Test'\n" );
 530     ok( !wcscmp( dataW, L"xxxxxxxx" ), "data is not 'xxxxxxxx'\n" );
 531
 532     res = RegSetValueExA( test_key, "Test", 0, REG_SZ, (const BYTE *)"foobar", 7 );
 533     ok( res == 0, "RegSetValueExA failed error %ld\n", res );
 534
 535     /* overflow both name and data */
 536     val_count = 2;
 537     data_count = 2;
 538     type = 1234;
 539     strcpy( value, "xxxxxxxxxx" );
 540     strcpy( data, "xxxxxxxxxx" );
 541     res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
 542     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 543     ok( val_count == 2, "val_count set to %ld\n", val_count );
 544     /* Chinese, Japanese, and Korean editions of Windows 10 sometimes set data_count to a higher value */
 545     ok( data_count == 7 || broken( data_count > 7 ), "data_count set to %ld instead of 7\n", data_count );
 546     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 547     ok( !strcmp( value, "xxxxxxxxxx" ), "value set to '%s'\n", value );
 548     ok( !strcmp( data, "xxxxxxxxxx" ), "data set to '%s'\n", data );
 549
 550     /* overflow name */
 551     val_count = 3;
 552     data_count = 16;
 553     type = 1234;
 554     strcpy( value, "xxxxxxxxxx" );
 555     memset( data, 'x', sizeof(data) );
 556     data[sizeof(data)-1] = '\0';
 557     res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
 558     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 559     ok( val_count == 3, "val_count set to %ld\n", val_count );
 560     /* In double-byte and UTF-8 locales Windows 10 may set data_count > 7,
 561      * potentially even more than the declared buffer size, in which case the
 562      * buffer is not NUL-terminated.
 563      */
 564     ok( data_count == 7 || broken( data_count > 7 ), "data_count set to %ld instead of 7\n", data_count );
 565     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 566     /* v5.1.2600.0 (XP Home and Professional) does not touch value or data in
 567      * this case. Neither does Windows 10 21H1 in UTF-8 locales.
 568      */
 569     ok( !strcmp( value, "Te" ) || !strcmp( value, "xxxxxxxxxx" ),
 570         "value set to '%s' instead of 'Te' or 'xxxxxxxxxx'\n", value );
 571     ok( !strcmp( data, "foobar" ) || !strcmp( data, "xxxxxxx" ) ||
 572         broken( data_count > 7 && data_count < 16 &&
 573                 strspn( data, "x" ) == data_count && data[data_count] == 0 ) ||
 574         broken( data_count >= 16 && strspn( data, "x" ) == sizeof(data) - 1 ),
 575         "data set to '%s' instead of 'foobar' or x's, data_count=%lu\n", data, data_count );
 576
 577     /* overflow empty name */
 578     val_count = 0;
 579     data_count = 16;
 580     type = 1234;
 581     strcpy( value, "xxxxxxxxxx" );
 582     memset( data, 'x', sizeof(data) );
 583     data[sizeof(data)-1] = '\0';
 584     res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
 585     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 586     ok( val_count == 0, "val_count set to %ld\n", val_count );
 587     /* See comment in 'overflow name' section */
 588     ok( data_count == 7 || broken( data_count > 7 ), "data_count set to %ld instead of 7\n", data_count );
 589     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 590     ok( !strcmp( value, "xxxxxxxxxx" ), "value set to '%s'\n", value );
 591     /* See comment in 'overflow name' section */
 592     ok( !strcmp( data, "foobar" ) || !strcmp( data, "xxxxxxx" ) ||
 593         broken( data_count > 7 && data_count < 16 &&
 594                 strspn( data, "x" ) == data_count && data[data_count] == 0 ) ||
 595         broken( data_count >= 16 && strspn( data, "x" ) == sizeof(data) - 1 ),
 596         "data set to '%s' instead of 'foobar' or x's, data_count=%lu\n", data, data_count );
 597
 598     /* overflow data */
 599     val_count = 20;
 600     data_count = 2;
 601     type = 1234;
 602     strcpy( value, "xxxxxxxxxx" );
 603     strcpy( data, "xxxxxxxxxx" );
 604     res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
 605     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 606     ok( val_count == 20, "val_count set to %ld\n", val_count );
 607     ok( data_count == 7, "data_count set to %ld instead of 7\n", data_count );
 608     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 609     ok( !strcmp( value, "xxxxxxxxxx" ), "value set to '%s'\n", value );
 610     ok( !strcmp( data, "xxxxxxxxxx" ), "data set to '%s'\n", data );
 611
 612     /* no overflow */
 613     val_count = 20;
 614     data_count = 20;
 615     type = 1234;
 616     strcpy( value, "xxxxxxxxxx" );
 617     strcpy( data, "xxxxxxxxxx" );
 618     res = RegEnumValueA( test_key, 0, value, &val_count, NULL, &type, (LPBYTE)data, &data_count );
 619     ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res );
 620     ok( val_count == 4, "val_count set to %ld instead of 4\n", val_count );
 621     ok( data_count == 7, "data_count set to %ld instead of 7\n", data_count );
 622     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 623     ok( !strcmp( value, "Test" ), "value is '%s' instead of Test\n", value );
 624     ok( !strcmp( data, "foobar" ), "data is '%s' instead of foobar\n", data );
 625
 626     if (pRegGetValueA) /* avoid a crash on Windows 2000 */
 627     {
 628         /* no value and no val_count parameter */
 629         data_count = 20;
 630         type = 1234;
 631         strcpy( data, "xxxxxxxxxx" );
 632         res = RegEnumValueA( test_key, 0, NULL, NULL, NULL, &type, (BYTE*)data, &data_count );
 633         ok( res == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", res );
 634
 635         /* no value parameter */
 636         val_count = 20;
 637         data_count = 20;
 638         type = 1234;
 639         strcpy( data, "xxxxxxxxxx" );
 640         res = RegEnumValueA( test_key, 0, NULL, &val_count, NULL, &type, (BYTE*)data, &data_count );
 641         ok( res == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", res );
 642
 643         /* no val_count parameter */
 644         data_count = 20;
 645         type = 1234;
 646         strcpy( value, "xxxxxxxxxx" );
 647         strcpy( data, "xxxxxxxxxx" );
 648         res = RegEnumValueA( test_key, 0, value, NULL, NULL, &type, (BYTE*)data, &data_count );
 649         ok( res == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", res );
 650     }
 651
 652     /* Unicode tests */
 653
 654     SetLastError(0xdeadbeef);
 655     res = RegSetValueExW( test_key, L"Test", 0, REG_SZ, (const BYTE *)L"foobar", 7*sizeof(WCHAR) );
 656     if (res==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 657     {
 658         win_skip("RegSetValueExW is not implemented\n");
 659         goto cleanup;
 660     }
 661     ok( res == 0, "RegSetValueExW failed error %ld\n", res );
 662
 663     /* overflow both name and data */
 664     val_count = 2;
 665     data_count = 2;
 666     type = 1234;
 667     wcscpy( valueW, L"xxxxxxxx" );
 668     wcscpy( dataW, L"xxxxxxxx" );
 669     res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
 670     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 671     ok( val_count == 2, "val_count set to %ld\n", val_count );
 672     ok( data_count == 7*sizeof(WCHAR), "data_count set to %ld instead of 7*sizeof(WCHAR)\n", data_count );
 673     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 674     ok( !wcscmp( valueW, L"xxxxxxxx" ), "value modified\n" );
 675     ok( !wcscmp( dataW, L"xxxxxxxx" ), "data modified\n" );
 676
 677     /* overflow name */
 678     val_count = 3;
 679     data_count = 20;
 680     type = 1234;
 681     wcscpy( valueW, L"xxxxxxxx" );
 682     wcscpy( dataW, L"xxxxxxxx" );
 683     res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
 684     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 685     ok( val_count == 3, "val_count set to %ld\n", val_count );
 686     ok( data_count == 7*sizeof(WCHAR), "data_count set to %ld instead of 7*sizeof(WCHAR)\n", data_count );
 687     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 688     ok( !wcscmp( valueW, L"xxxxxxxx" ), "value modified\n" );
 689     ok( !wcscmp( dataW, L"xxxxxxxx" ), "data modified\n" );
 690
 691     /* overflow data */
 692     val_count = 20;
 693     data_count = 2;
 694     type = 1234;
 695     wcscpy( valueW, L"xxxxxxxx" );
 696     wcscpy( dataW, L"xxxxxxxx" );
 697     res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
 698     ok( res == ERROR_MORE_DATA, "expected ERROR_MORE_DATA, got %ld\n", res );
 699     ok( val_count == 4, "val_count set to %ld instead of 4\n", val_count );
 700     ok( data_count == 7*sizeof(WCHAR), "data_count set to %ld instead of 7*sizeof(WCHAR)\n", data_count );
 701     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 702     ok( !wcscmp( valueW, L"Test" ), "value is not 'Test'\n" );
 703     ok( !wcscmp( dataW, L"xxxxxxxx" ), "data modified\n" );
 704
 705     /* no overflow */
 706     val_count = 20;
 707     data_count = 20;
 708     type = 1234;
 709     wcscpy( valueW, L"xxxxxxxx" );
 710     wcscpy( dataW, L"xxxxxxxx" );
 711     res = RegEnumValueW( test_key, 0, valueW, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
 712     ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res );
 713     ok( val_count == 4, "val_count set to %ld instead of 4\n", val_count );
 714     ok( data_count == 7*sizeof(WCHAR), "data_count set to %ld instead of 7*sizeof(WCHAR)\n", data_count );
 715     ok( type == REG_SZ, "type %ld is not REG_SZ\n", type );
 716     ok( !wcscmp( valueW, L"Test" ), "value is not 'Test'\n" );
 717     ok( !wcscmp( dataW, L"foobar" ), "data is not 'foobar'\n" );
 718
 719     if (pRegGetValueA) /* avoid a crash on Windows 2000 */
 720     {
 721         /* no valueW and no val_count parameter */
 722         data_count = 20;
 723         type = 1234;
 724         wcscpy( dataW, L"xxxxxxxx" );
 725         res = RegEnumValueW( test_key, 0, NULL, NULL, NULL, &type, (BYTE*)dataW, &data_count );
 726         ok( res == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", res );
 727
 728         /* no valueW parameter */
 729         val_count = 20;
 730         data_count = 20;
 731         type = 1234;
 732         wcscpy( dataW, L"xxxxxxxx" );
 733         res = RegEnumValueW( test_key, 0, NULL, &val_count, NULL, &type, (BYTE*)dataW, &data_count );
 734         ok( res == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", res );
 735
 736         /* no val_count parameter */
 737         data_count = 20;
 738         type = 1234;
 739         wcscpy( valueW, L"xxxxxxxx" );
 740         wcscpy( dataW, L"xxxxxxxx" );
 741         res = RegEnumValueW( test_key, 0, valueW, NULL, NULL, &type, (BYTE*)dataW, &data_count );
 742         ok( res == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", res );
 743     }
 744
 745 cleanup:
 746     RegDeleteKeyA(test_key, "");
 747     RegCloseKey(test_key);
 748 }
 749
 750 static void test_query_value_ex(void)
 751 {
 752     DWORD ret, size, type;
 753     BYTE buffer[10];
 754
 755     size = sizeof(buffer);
 756     ret = RegQueryValueExA(hkey_main, "TP1_SZ", NULL, &type, NULL, &size);
 757     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
 758     ok(size == strlen(sTestpath1) + 1, "(%ld,%ld)\n", (DWORD)strlen(sTestpath1) + 1, size);
 759     ok(type == REG_SZ, "type %ld is not REG_SZ\n", type);
 760
 761     type = 0xdeadbeef;
 762     size = 0xdeadbeef;
 763     ret = RegQueryValueExA(HKEY_CLASSES_ROOT, "Nonexistent Value", NULL, &type, NULL, &size);
 764     ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
 765     ok(size == 0, "size should have been set to 0 instead of %ld\n", size);
 766
 767     size = sizeof(buffer);
 768     ret = RegQueryValueExA(HKEY_CLASSES_ROOT, "Nonexistent Value", NULL, &type, buffer, &size);
 769     ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
 770     ok(size == sizeof(buffer), "size shouldn't have been changed to %ld\n", size);
 771
 772     size = 4;
 773     ret = RegQueryValueExA(hkey_main, "BIN32", NULL, &size, buffer, &size);
 774     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
 775 }
 776
 777 static void test_get_value(void)
 778 {
 779     DWORD ret;
 780     DWORD size;
 781     DWORD type;
 782     DWORD dw, qw[2];
 783     CHAR buf[80];
 784     CHAR expanded[] = "bar\\subdir1";
 785     CHAR expanded2[] = "ImARatherLongButIndeedNeededString\\subdir1";
 786
 787     if(!pRegGetValueA)
 788     {
 789         win_skip("RegGetValue not available on this platform\n");
 790         return;
 791     }
 792
 793     /* Invalid parameter */
 794     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD, &type, &dw, NULL);
 795     ok(ret == ERROR_INVALID_PARAMETER, "ret=%ld\n", ret);
 796
 797     /* Query REG_DWORD using RRF_RT_REG_DWORD (ok) */
 798     size = type = dw = 0xdeadbeef;
 799     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD, &type, &dw, &size);
 800     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 801     ok(size == 4, "size=%ld\n", size);
 802     ok(type == REG_DWORD, "type=%ld\n", type);
 803     ok(dw == 0x12345678, "dw=%ld\n", dw);
 804
 805     /* Check RRF_SUBKEY_WOW64*KEY validation on a case without a subkey */
 806     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD | RRF_SUBKEY_WOW6464KEY | RRF_SUBKEY_WOW6432KEY, NULL, NULL, NULL);
 807     ok(ret == ERROR_INVALID_PARAMETER || broken(ret == ERROR_SUCCESS), /* Before Win10 */
 808        "ret=%ld\n", ret);
 809     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD | RRF_SUBKEY_WOW6464KEY, NULL, NULL, NULL);
 810     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 811     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_DWORD | RRF_SUBKEY_WOW6432KEY, NULL, NULL, NULL);
 812     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 813
 814     /* Query by subkey-name */
 815     ret = pRegGetValueA(HKEY_CURRENT_USER, "Software\\Wine\\Test", "DWORD", RRF_RT_REG_DWORD, NULL, NULL, NULL);
 816     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 817
 818     /* Check RRF_SUBKEY_WOW64*KEY validation on a case with a subkey */
 819     ret = pRegGetValueA(HKEY_CURRENT_USER, "Software\\Wine\\Test", "DWORD", RRF_RT_REG_DWORD | RRF_SUBKEY_WOW6464KEY | RRF_SUBKEY_WOW6432KEY, NULL, NULL, NULL);
 820     ok(ret == ERROR_INVALID_PARAMETER || broken(ret == ERROR_SUCCESS), /* Before Win10 */
 821        "ret=%ld\n", ret);
 822     ret = pRegGetValueA(HKEY_CURRENT_USER, "Software\\Wine\\Test", "DWORD", RRF_RT_REG_DWORD | RRF_SUBKEY_WOW6464KEY, NULL, NULL, NULL);
 823     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 824     ret = pRegGetValueA(HKEY_CURRENT_USER, "Software\\Wine\\Test", "DWORD", RRF_RT_REG_DWORD | RRF_SUBKEY_WOW6432KEY, NULL, NULL, NULL);
 825     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 826
 827     /* Query REG_DWORD using RRF_RT_REG_BINARY (restricted) */
 828     size = type = dw = 0xdeadbeef;
 829     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_BINARY, &type, &dw, &size);
 830     ok(ret == ERROR_UNSUPPORTED_TYPE, "ret=%ld\n", ret);
 831     /* Although the function failed all values are retrieved */
 832     ok(size == 4, "size=%ld\n", size);
 833     ok(type == REG_DWORD, "type=%ld\n", type);
 834     ok(dw == 0x12345678, "dw=%ld\n", dw);
 835
 836     /* Test RRF_ZEROONFAILURE */
 837     type = dw = 0xdeadbeef; size = 4;
 838     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_SZ|RRF_ZEROONFAILURE, &type, &dw, &size);
 839     ok(ret == ERROR_UNSUPPORTED_TYPE, "ret=%ld\n", ret);
 840     /* Again all values are retrieved ... */
 841     ok(size == 4, "size=%ld\n", size);
 842     ok(type == REG_DWORD, "type=%ld\n", type);
 843     /* ... except the buffer, which is zeroed out */
 844     ok(dw == 0, "dw=%ld\n", dw);
 845
 846     /* Test RRF_ZEROONFAILURE with a NULL buffer... */
 847     type = size = 0xbadbeef;
 848     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_REG_SZ|RRF_ZEROONFAILURE, &type, NULL, &size);
 849     ok(ret == ERROR_UNSUPPORTED_TYPE, "ret=%ld\n", ret);
 850     ok(size == 4, "size=%ld\n", size);
 851     ok(type == REG_DWORD, "type=%ld\n", type);
 852
 853     /* Query REG_DWORD using RRF_RT_DWORD (ok) */
 854     size = type = dw = 0xdeadbeef;
 855     ret = pRegGetValueA(hkey_main, NULL, "DWORD", RRF_RT_DWORD, &type, &dw, &size);
 856     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 857     ok(size == 4, "size=%ld\n", size);
 858     ok(type == REG_DWORD, "type=%ld\n", type);
 859     ok(dw == 0x12345678, "dw=%ld\n", dw);
 860
 861     /* Query 32-bit REG_BINARY using RRF_RT_DWORD (ok) */
 862     size = type = dw = 0xdeadbeef;
 863     ret = pRegGetValueA(hkey_main, NULL, "BIN32", RRF_RT_DWORD, &type, &dw, &size);
 864     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 865     ok(size == 4, "size=%ld\n", size);
 866     ok(type == REG_BINARY, "type=%ld\n", type);
 867     ok(dw == 0x12345678, "dw=%ld\n", dw);
 868
 869     /* Query 64-bit REG_BINARY using RRF_RT_DWORD (type mismatch) */
 870     qw[0] = qw[1] = size = type = 0xdeadbeef;
 871     ret = pRegGetValueA(hkey_main, NULL, "BIN64", RRF_RT_DWORD, &type, qw, &size);
 872     ok(ret == ERROR_DATATYPE_MISMATCH, "ret=%ld\n", ret);
 873     ok(size == 8, "size=%ld\n", size);
 874     ok(type == REG_BINARY, "type=%ld\n", type);
 875     ok(qw[0] == 0x12345678 &&
 876        qw[1] == 0x87654321, "qw={%ld,%ld}\n", qw[0], qw[1]);
 877
 878     /* Query 64-bit REG_BINARY using 32-bit buffer (buffer too small) */
 879     type = dw = 0xdeadbeef; size = 4;
 880     ret = pRegGetValueA(hkey_main, NULL, "BIN64", RRF_RT_REG_BINARY, &type, &dw, &size);
 881     ok(ret == ERROR_MORE_DATA, "ret=%ld\n", ret);
 882     ok(dw == 0xdeadbeef, "dw=%ld\n", dw);
 883     ok(size == 8, "size=%ld\n", size);
 884
 885     /* Query 64-bit REG_BINARY using RRF_RT_QWORD (ok) */
 886     qw[0] = qw[1] = size = type = 0xdeadbeef;
 887     ret = pRegGetValueA(hkey_main, NULL, "BIN64", RRF_RT_QWORD, &type, qw, &size);
 888     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 889     ok(size == 8, "size=%ld\n", size);
 890     ok(type == REG_BINARY, "type=%ld\n", type);
 891     ok(qw[0] == 0x12345678 &&
 892        qw[1] == 0x87654321, "qw={%ld,%ld}\n", qw[0], qw[1]);
 893
 894     /* Query REG_SZ using RRF_RT_REG_SZ (ok) */
 895     buf[0] = 0; type = 0xdeadbeef; size = sizeof(buf);
 896     ret = pRegGetValueA(hkey_main, NULL, "TP1_SZ", RRF_RT_REG_SZ, &type, buf, &size);
 897     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 898     ok(size == strlen(sTestpath1)+1, "strlen(sTestpath1)=%d size=%ld\n", lstrlenA(sTestpath1), size);
 899     ok(type == REG_SZ, "type=%ld\n", type);
 900     ok(!strcmp(sTestpath1, buf), "sTestpath=\"%s\" buf=\"%s\"\n", sTestpath1, buf);
 901
 902     /* Query REG_SZ using RRF_RT_REG_SZ and no buffer (ok) */
 903     type = 0xdeadbeef; size = 0;
 904     ret = pRegGetValueA(hkey_main, NULL, "TP1_SZ", RRF_RT_REG_SZ, &type, NULL, &size);
 905     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 906     /* v5.2.3790.1830 (2003 SP1) returns sTestpath1 length + 2 here. */
 907     ok(size == strlen(sTestpath1)+1 || broken(size == strlen(sTestpath1)+2),
 908        "strlen(sTestpath1)=%d size=%ld\n", lstrlenA(sTestpath1), size);
 909     ok(type == REG_SZ, "type=%ld\n", type);
 910
 911     /* Query REG_SZ using RRF_RT_REG_SZ on a zero-byte value (ok) */
 912     strcpy(buf, sTestpath1);
 913     type = 0xdeadbeef;
 914     size = 0;
 915     ret = pRegGetValueA(hkey_main, NULL, "TP1_ZB_SZ", RRF_RT_REG_SZ, &type, NULL, &size);
 916     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 917     ok(size == 1, "size=%ld\n", size);
 918     ok(type == REG_SZ, "type=%ld\n", type);
 919     ret = pRegGetValueA(hkey_main, NULL, "TP1_ZB_SZ", RRF_RT_REG_SZ, &type, buf, &size);
 920     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 921     ok(size == 1, "size=%ld\n", size);
 922     ok(type == REG_SZ, "type=%ld\n", type);
 923     ok(!strcmp(buf, ""), "Expected \"\", got \"%s\"\n", buf);
 924
 925     /* Query REG_SZ using RRF_RT_REG_SZ|RRF_NOEXPAND (ok) */
 926     buf[0] = 0; type = 0xdeadbeef; size = sizeof(buf);
 927     ret = pRegGetValueA(hkey_main, NULL, "TP1_SZ", RRF_RT_REG_SZ|RRF_NOEXPAND, &type, buf, &size);
 928     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 929     ok(size == strlen(sTestpath1)+1, "strlen(sTestpath1)=%d size=%ld\n", lstrlenA(sTestpath1), size);
 930     ok(type == REG_SZ, "type=%ld\n", type);
 931     ok(!strcmp(sTestpath1, buf), "sTestpath=\"%s\" buf=\"%s\"\n", sTestpath1, buf);
 932
 933     /* Query REG_EXPAND_SZ using RRF_RT_REG_SZ and no buffer (ok, expands) */
 934     size = 0;
 935     ret = pRegGetValueA(hkey_main, NULL, "TP2_EXP_SZ", RRF_RT_REG_SZ, NULL, NULL, &size);
 936     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 937     todo_wine ok(size == strlen(expanded2)+2,
 938        "strlen(expanded2)=%d, strlen(sTestpath2)=%d, size=%ld\n", lstrlenA(expanded2), lstrlenA(sTestpath2), size);
 939
 940     /* Query REG_EXPAND_SZ using RRF_RT_REG_SZ (ok, expands) */
 941     buf[0] = 0; type = 0xdeadbeef; size = sizeof(buf);
 942     ret = pRegGetValueA(hkey_main, NULL, "TP1_EXP_SZ", RRF_RT_REG_SZ, &type, buf, &size);
 943     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 944     todo_wine ok(size == strlen(sTestpath1)+1,
 945        "strlen(expanded)=%d, strlen(sTestpath1)=%d, size=%ld\n", lstrlenA(expanded), lstrlenA(sTestpath1), size);
 946     ok(type == REG_SZ, "type=%ld\n", type);
 947     ok(!strcmp(expanded, buf), "expanded=\"%s\" buf=\"%s\"\n", expanded, buf);
 948
 949     /* Query REG_EXPAND_SZ using RRF_RT_REG_SZ (ok, expands a lot) */
 950     buf[0] = 0; type = 0xdeadbeef; size = sizeof(buf);
 951     ret = pRegGetValueA(hkey_main, NULL, "TP2_EXP_SZ", RRF_RT_REG_SZ, &type, buf, &size);
 952     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 953     ok(size == strlen(expanded2)+1,
 954         "strlen(expanded2)=%d, strlen(sTestpath1)=%d, size=%ld\n", lstrlenA(expanded2), lstrlenA(sTestpath2), size);
 955     ok(type == REG_SZ, "type=%ld\n", type);
 956     ok(!strcmp(expanded2, buf), "expanded2=\"%s\" buf=\"%s\"\n", expanded2, buf);
 957
 958     /* Query REG_EXPAND_SZ using RRF_RT_REG_EXPAND_SZ|RRF_NOEXPAND (ok, doesn't expand) */
 959     buf[0] = 0; type = 0xdeadbeef; size = sizeof(buf);
 960     ret = pRegGetValueA(hkey_main, NULL, "TP1_EXP_SZ", RRF_RT_REG_EXPAND_SZ|RRF_NOEXPAND, &type, buf, &size);
 961     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 962     ok(size == strlen(sTestpath1)+1, "strlen(sTestpath1)=%d size=%ld\n", lstrlenA(sTestpath1), size);
 963     ok(type == REG_EXPAND_SZ, "type=%ld\n", type);
 964     ok(!strcmp(sTestpath1, buf), "sTestpath=\"%s\" buf=\"%s\"\n", sTestpath1, buf);
 965
 966     /* Query REG_EXPAND_SZ using RRF_RT_REG_EXPAND_SZ|RRF_NOEXPAND and no buffer (ok, doesn't expand) */
 967     size = 0xbadbeef;
 968     ret = pRegGetValueA(hkey_main, NULL, "TP1_EXP_SZ", RRF_RT_REG_EXPAND_SZ|RRF_NOEXPAND, NULL, NULL, &size);
 969     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 970     todo_wine ok(size == strlen(sTestpath1)+2, "strlen(sTestpath1)=%d size=%ld\n", lstrlenA(sTestpath1), size);
 971
 972     /* Query REG_EXPAND_SZ using RRF_RT_REG_SZ|RRF_NOEXPAND (type mismatch) */
 973     ret = pRegGetValueA(hkey_main, NULL, "TP1_EXP_SZ", RRF_RT_REG_SZ|RRF_NOEXPAND, NULL, NULL, NULL);
 974     ok(ret == ERROR_UNSUPPORTED_TYPE, "ret=%ld\n", ret);
 975
 976     /* Query REG_EXPAND_SZ using RRF_RT_REG_EXPAND_SZ (not allowed without RRF_NOEXPAND) */
 977     ret = pRegGetValueA(hkey_main, NULL, "TP1_EXP_SZ", RRF_RT_REG_EXPAND_SZ, NULL, NULL, NULL);
 978     /* before win8: ERROR_INVALID_PARAMETER, win8: ERROR_UNSUPPORTED_TYPE */
 979     ok(ret == ERROR_INVALID_PARAMETER || ret == ERROR_UNSUPPORTED_TYPE, "ret=%ld\n", ret);
 980
 981     /* Query REG_EXPAND_SZ using RRF_RT_ANY */
 982     buf[0] = 0; type = 0xdeadbeef; size = sizeof(buf);
 983     ret = pRegGetValueA(hkey_main, NULL, "TP1_EXP_SZ", RRF_RT_ANY, &type, buf, &size);
 984     ok(ret == ERROR_SUCCESS, "ret=%ld\n", ret);
 985     todo_wine ok(size == strlen(sTestpath1)+1,
 986         "strlen(expanded)=%d, strlen(sTestpath1)=%d, size=%ld\n", lstrlenA(expanded), lstrlenA(sTestpath1), size);
 987     ok(type == REG_SZ, "type=%ld\n", type);
 988     ok(!strcmp(expanded, buf), "expanded=\"%s\" buf=\"%s\"\n", expanded, buf);
 989 }
 990
 991 static void test_reg_open_key(void)
 992 {
 993     DWORD ret = 0;
 994     HKEY hkResult = NULL;
 995     HKEY hkPreserve = NULL;
 996     HKEY hkRoot64 = NULL;
 997     HKEY hkRoot32 = NULL;
 998     BOOL bRet;
 999     SID_IDENTIFIER_AUTHORITY sid_authority = {SECURITY_WORLD_SID_AUTHORITY};
1000     PSID world_sid;
1001     EXPLICIT_ACCESSA access;
1002     PACL key_acl;
1003     SECURITY_DESCRIPTOR *sd;
1004
1005     /* successful open */
1006     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkResult);
1007     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1008     ok(hkResult != NULL, "expected hkResult != NULL\n");
1009     hkPreserve = hkResult;
1010
1011     /* open same key twice */
1012     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkResult);
1013     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1014     ok(hkResult != hkPreserve, "expected hkResult != hkPreserve\n");
1015     ok(hkResult != NULL, "hkResult != NULL\n");
1016     RegCloseKey(hkResult);
1017
1018     /* trailing slashes */
1019     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test\\\\", &hkResult);
1020     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1021     RegCloseKey(hkResult);
1022
1023     /* open nonexistent key
1024     * check that hkResult is set to NULL
1025     */
1026     hkResult = hkPreserve;
1027     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Nonexistent", &hkResult);
1028     ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
1029     ok(hkResult == NULL, "expected hkResult == NULL\n");
1030
1031     /* open the same nonexistent key again to make sure the key wasn't created */
1032     hkResult = hkPreserve;
1033     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Nonexistent", &hkResult);
1034     ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
1035     ok(hkResult == NULL, "expected hkResult == NULL\n");
1036
1037     /* send in NULL lpSubKey
1038     * check that hkResult receives the value of hKey
1039     */
1040     hkResult = hkPreserve;
1041     ret = RegOpenKeyA(HKEY_CURRENT_USER, NULL, &hkResult);
1042     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1043     ok(hkResult == HKEY_CURRENT_USER, "expected hkResult == HKEY_CURRENT_USER\n");
1044
1045     /* send empty-string in lpSubKey */
1046     hkResult = hkPreserve;
1047     ret = RegOpenKeyA(HKEY_CURRENT_USER, "", &hkResult);
1048     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1049     ok(hkResult == HKEY_CURRENT_USER, "expected hkResult == HKEY_CURRENT_USER\n");
1050
1051     /* send in NULL lpSubKey and NULL hKey
1052     * hkResult is set to NULL
1053     */
1054     hkResult = hkPreserve;
1055     ret = RegOpenKeyA(NULL, NULL, &hkResult);
1056     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1057     ok(hkResult == NULL, "expected hkResult == NULL\n");
1058
1059     /* only send NULL hKey
1060      * the value of hkResult remains unchanged
1061      */
1062     hkResult = hkPreserve;
1063     ret = RegOpenKeyA(NULL, "Software\\Wine\\Test", &hkResult);
1064     ok(ret == ERROR_INVALID_HANDLE || ret == ERROR_BADKEY, /* Windows 95 returns BADKEY */
1065        "expected ERROR_INVALID_HANDLE or ERROR_BADKEY, got %ld\n", ret);
1066     ok(hkResult == hkPreserve, "expected hkResult == hkPreserve\n");
1067
1068     /* send in NULL hkResult */
1069     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", NULL);
1070     ok(ret == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", ret);
1071
1072     ret = RegOpenKeyA(HKEY_CURRENT_USER, NULL, NULL);
1073     ok(ret == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", ret);
1074
1075     ret = RegOpenKeyA(NULL, NULL, NULL);
1076     ok(ret == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", ret);
1077
1078     /*  beginning backslash character */
1079     ret = RegOpenKeyA(HKEY_CURRENT_USER, "\\Software\\Wine\\Test", &hkResult);
1080     ok(ret == ERROR_BAD_PATHNAME || broken(ret == ERROR_SUCCESS),  /* wow64 */
1081        "expected ERROR_BAD_PATHNAME or ERROR_FILE_NOT_FOUND, got %ld\n", ret);
1082     if (!ret) RegCloseKey(hkResult);
1083
1084     hkResult = NULL;
1085     ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, "\\clsid", 0, KEY_QUERY_VALUE, &hkResult);
1086     ok(ret == ERROR_SUCCESS,
1087        "expected ERROR_SUCCESS, ERROR_BAD_PATHNAME or ERROR_FILE_NOT_FOUND, got %ld\n", ret);
1088     RegCloseKey(hkResult);
1089
1090     /* NULL or empty subkey of special root */
1091     hkResult = NULL;
1092     ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, NULL, 0, KEY_QUERY_VALUE, &hkResult);
1093     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1094     ok(hkResult == HKEY_CLASSES_ROOT, "expected hkResult == HKEY_CLASSES_ROOT\n");
1095
1096     hkResult = NULL;
1097     ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, "", 0, KEY_QUERY_VALUE, &hkResult);
1098     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1099     ok(hkResult == HKEY_CLASSES_ROOT, "expected hkResult == HKEY_CLASSES_ROOT\n");
1100
1101     hkResult = NULL;
1102     ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, "\\", 0, KEY_QUERY_VALUE, &hkResult);
1103     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1104     ok(hkResult != HKEY_CLASSES_ROOT, "expected hkResult to be a new key\n");
1105     ok(!RegCloseKey(hkResult), "got invalid hkey\n");
1106
1107     /* empty subkey of existing handle */
1108     hkResult = hkPreserve;
1109     ret = RegOpenKeyExA(hkPreserve, "", 0, KEY_QUERY_VALUE, &hkResult);
1110     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1111     ok(hkResult != hkPreserve, "expected hkResult != hkPreserve\n");
1112     ok(!RegCloseKey(hkResult), "got invalid hkey\n");
1113
1114     /* NULL subkey of existing handle */
1115     hkResult = hkPreserve;
1116     ret = RegOpenKeyExA(hkPreserve, NULL, 0, KEY_QUERY_VALUE, &hkResult);
1117     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1118     ok(hkResult != hkPreserve, "expected hkResult != hkPreserve\n");
1119     ok(!RegCloseKey(hkResult), "got invalid hkey\n");
1120
1121     /* empty subkey of NULL */
1122     hkResult = hkPreserve;
1123     ret = RegOpenKeyExW(NULL, L"", 0, KEY_QUERY_VALUE, &hkResult);
1124     ok(ret == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %ld\n", ret);
1125     ok(hkResult == NULL, "expected hkResult == NULL\n");
1126
1127     hkResult = hkPreserve;
1128     ret = RegOpenKeyExA(NULL, "", 0, KEY_QUERY_VALUE, &hkResult);
1129     ok(ret == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %ld\n", ret);
1130     ok(hkResult == hkPreserve, "expected hkResult == hkPreserve\n");
1131
1132     RegCloseKey(hkPreserve);
1133
1134     /* WOW64 flags */
1135     hkResult = NULL;
1136     ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software", 0, KEY_READ|KEY_WOW64_32KEY, &hkResult);
1137     ok(ret == ERROR_SUCCESS && hkResult, "RegOpenKeyEx with KEY_WOW64_32KEY failed (err=%lu)\n", ret);
1138     RegCloseKey(hkResult);
1139
1140     hkResult = NULL;
1141     ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software", 0, KEY_READ|KEY_WOW64_64KEY, &hkResult);
1142     ok(ret == ERROR_SUCCESS && hkResult, "RegOpenKeyEx with KEY_WOW64_64KEY failed (err=%lu)\n", ret);
1143     RegCloseKey(hkResult);
1144
1145     /* check special HKEYs on 64bit
1146      * only the lower 4 bytes of the supplied key are used
1147      */
1148     if (ptr_size == 64)
1149     {
1150         /* HKEY_CURRENT_USER */
1151         ret = RegOpenKeyA(UlongToHandle(HandleToUlong(HKEY_CURRENT_USER)), "Software", &hkResult);
1152         ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1153         ok(hkResult != NULL, "expected hkResult != NULL\n");
1154         RegCloseKey(hkResult);
1155
1156         ret = RegOpenKeyA((HKEY)(HandleToUlong(HKEY_CURRENT_USER) | (ULONG64)1 << 32), "Software", &hkResult);
1157         ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1158         ok(hkResult != NULL, "expected hkResult != NULL\n");
1159         RegCloseKey(hkResult);
1160
1161         ret = RegOpenKeyA((HKEY)(HandleToUlong(HKEY_CURRENT_USER) | (ULONG64)0xdeadbeef << 32), "Software", &hkResult);
1162         ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1163         ok(hkResult != NULL, "expected hkResult != NULL\n");
1164         RegCloseKey(hkResult);
1165
1166         ret = RegOpenKeyA((HKEY)(HandleToUlong(HKEY_CURRENT_USER) | (ULONG64)0xffffffff << 32), "Software", &hkResult);
1167         ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1168         ok(hkResult != NULL, "expected hkResult != NULL\n");
1169         RegCloseKey(hkResult);
1170
1171         /* HKEY_LOCAL_MACHINE */
1172         ret = RegOpenKeyA((HKEY)(HandleToUlong(HKEY_LOCAL_MACHINE) | (ULONG64)0xdeadbeef << 32), "Software", &hkResult);
1173         ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1174         ok(hkResult != NULL, "expected hkResult != NULL\n");
1175         RegCloseKey(hkResult);
1176     }
1177
1178     /* Try using WOW64 flags when opening a key with a DACL set to verify that
1179      * the registry access check is performed correctly. Redirection isn't
1180      * being tested, so the tests don't care about whether the process is
1181      * running under WOW64. */
1182     if (!is_64bit)
1183     {
1184         skip("Not running WoW64 tests on 32-bit\n");
1185         return;
1186     }
1187
1188     ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
1189                           KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &hkRoot32, NULL);
1190     ok(ret == ERROR_SUCCESS || ret == ERROR_ACCESS_DENIED,
1191        "RegCreateKeyEx with KEY_WOW64_32KEY failed (err=%lu)\n", ret);
1192     if (ret == ERROR_ACCESS_DENIED) return;
1193     ok(hkRoot32 != NULL, "hkRoot32 was set\n");
1194
1195     ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
1196                           KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &hkRoot64, NULL);
1197     ok(ret == ERROR_SUCCESS || ret == ERROR_ACCESS_DENIED,
1198        "RegCreateKeyEx with KEY_WOW64_64KEY failed (err=%lu)\n", ret);
1199     if (ret == ERROR_ACCESS_DENIED)
1200     {
1201         RegDeleteKeyA(hkRoot32, "");
1202         RegCloseKey(hkRoot32);
1203         return;
1204     }
1205     ok(hkRoot64 != NULL, "hkRoot64 was set\n");
1206
1207     bRet = AllocateAndInitializeSid(&sid_authority, 1, SECURITY_WORLD_RID,
1208                                     0, 0, 0, 0, 0, 0, 0, &world_sid);
1209     ok(bRet == TRUE,
1210        "Expected AllocateAndInitializeSid to return TRUE, got %d, last error %lu\n", bRet, GetLastError());
1211
1212     access.grfAccessPermissions = GENERIC_ALL | STANDARD_RIGHTS_ALL;
1213     access.grfAccessMode = SET_ACCESS;
1214     access.grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
1215     access.Trustee.pMultipleTrustee = NULL;
1216     access.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
1217     access.Trustee.TrusteeForm = TRUSTEE_IS_SID;
1218     access.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
1219     access.Trustee.ptstrName = (char *)world_sid;
1220
1221     ret = SetEntriesInAclA(1, &access, NULL, &key_acl);
1222     ok(ret == ERROR_SUCCESS,
1223        "Expected SetEntriesInAclA to return ERROR_SUCCESS, got %lu, last error %lu\n", ret, GetLastError());
1224
1225     sd = malloc(SECURITY_DESCRIPTOR_MIN_LENGTH);
1226     bRet = InitializeSecurityDescriptor(sd, SECURITY_DESCRIPTOR_REVISION);
1227     ok(bRet == TRUE,
1228        "Expected InitializeSecurityDescriptor to return TRUE, got %d, last error %lu\n", bRet, GetLastError());
1229
1230     bRet = SetSecurityDescriptorDacl(sd, TRUE, key_acl, FALSE);
1231     ok(bRet == TRUE,
1232        "Expected SetSecurityDescriptorDacl to return TRUE, got %d, last error %lu\n", bRet, GetLastError());
1233
1234     if (limited_user)
1235     {
1236         skip("not enough privileges to modify HKLM\n");
1237     }
1238     else
1239     {
1240         LONG error;
1241
1242         error = RegSetKeySecurity(hkRoot64, DACL_SECURITY_INFORMATION, sd);
1243         ok(error == ERROR_SUCCESS,
1244            "Expected RegSetKeySecurity to return success, got error %lu\n", error);
1245
1246         error = RegSetKeySecurity(hkRoot32, DACL_SECURITY_INFORMATION, sd);
1247         ok(error == ERROR_SUCCESS,
1248            "Expected RegSetKeySecurity to return success, got error %lu\n", error);
1249
1250         hkResult = NULL;
1251         ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, KEY_WOW64_64KEY | KEY_READ, &hkResult);
1252         ok(ret == ERROR_SUCCESS, "RegOpenKeyEx with KEY_WOW64_64KEY failed (err=%lu)\n", ret);
1253         ok(hkResult != NULL, "hkResult wasn't set\n");
1254         RegCloseKey(hkResult);
1255
1256         hkResult = NULL;
1257         ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, KEY_WOW64_32KEY | KEY_READ, &hkResult);
1258         ok(ret == ERROR_SUCCESS, "RegOpenKeyEx with KEY_WOW64_32KEY failed (err=%lu)\n", ret);
1259         ok(hkResult != NULL, "hkResult wasn't set\n");
1260         RegCloseKey(hkResult);
1261     }
1262
1263     free(sd);
1264     LocalFree(key_acl);
1265     FreeSid(world_sid);
1266     RegDeleteKeyA(hkRoot64, "");
1267     RegCloseKey(hkRoot64);
1268     RegDeleteKeyA(hkRoot32, "");
1269     RegCloseKey(hkRoot32);
1270 }
1271
1272 static void test_reg_create_key(void)
1273 {
1274     LONG ret;
1275     HKEY hkey1, hkey2;
1276     HKEY hkRoot64 = NULL;
1277     HKEY hkRoot32 = NULL;
1278     DWORD dwRet;
1279     BOOL bRet;
1280     SID_IDENTIFIER_AUTHORITY sid_authority = {SECURITY_WORLD_SID_AUTHORITY};
1281     PSID world_sid;
1282     EXPLICIT_ACCESSA access;
1283     PACL key_acl;
1284     SECURITY_DESCRIPTOR *sd;
1285
1286     /* NULL return key check */
1287     ret = RegCreateKeyA(hkey_main, "Subkey1", NULL);
1288     ok(ret == ERROR_INVALID_PARAMETER, "Got unexpected ret %ld.\n", ret);
1289
1290     ret = RegCreateKeyW(hkey_main, L"Subkey1", NULL);
1291     ok(ret == ERROR_INVALID_PARAMETER, "Got unexpected ret %ld.\n", ret);
1292
1293     ret = RegCreateKeyExA(hkey_main, "Subkey1", 0, NULL, 0, KEY_NOTIFY, NULL, NULL, NULL);
1294     ok(ret == ERROR_BADKEY, "Got unexpected ret %ld.\n", ret);
1295
1296     ret = RegCreateKeyExW(hkey_main, L"Subkey1", 0, NULL, 0, KEY_NOTIFY, NULL, NULL, NULL);
1297     ok(ret == ERROR_BADKEY, "Got unexpected ret %ld.\n", ret);
1298
1299     ret = RegCreateKeyExA(hkey_main, "Subkey1", 0, NULL, 0, KEY_NOTIFY, NULL, &hkey1, NULL);
1300     ok(!ret, "RegCreateKeyExA failed with error %ld\n", ret);
1301     /* should succeed: all versions of Windows ignore the access rights
1302      * to the parent handle */
1303     ret = RegCreateKeyExA(hkey1, "Subkey2", 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey2, NULL);
1304     ok(!ret, "RegCreateKeyExA failed with error %ld\n", ret);
1305
1306     /* clean up */
1307     RegDeleteKeyA(hkey2, "");
1308     RegDeleteKeyA(hkey1, "");
1309     RegCloseKey(hkey2);
1310     RegCloseKey(hkey1);
1311
1312     /* test creation of volatile keys */
1313     ret = RegCreateKeyExA(hkey_main, "Volatile", 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey1, NULL);
1314     ok(!ret, "RegCreateKeyExA failed with error %ld\n", ret);
1315     ret = RegCreateKeyExA(hkey1, "Subkey2", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey2, NULL);
1316     ok(ret == ERROR_CHILD_MUST_BE_VOLATILE, "RegCreateKeyExA failed with error %ld\n", ret);
1317     if (!ret) RegCloseKey( hkey2 );
1318     ret = RegCreateKeyExA(hkey1, "Subkey2", 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey2, NULL);
1319     ok(!ret, "RegCreateKeyExA failed with error %ld\n", ret);
1320     RegCloseKey(hkey2);
1321     /* should succeed if the key already exists */
1322     ret = RegCreateKeyExA(hkey1, "Subkey2", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey2, NULL);
1323     ok(!ret, "RegCreateKeyExA failed with error %ld\n", ret);
1324
1325     /* clean up */
1326     RegDeleteKeyA(hkey2, "");
1327     RegDeleteKeyA(hkey1, "");
1328     RegCloseKey(hkey2);
1329     RegCloseKey(hkey1);
1330
1331     /*  beginning backslash character */
1332     ret = RegCreateKeyExA(hkey_main, "\\Subkey3", 0, NULL, 0, KEY_NOTIFY, NULL, &hkey1, NULL);
1333     ok(ret == ERROR_BAD_PATHNAME, "expected ERROR_BAD_PATHNAME, got %ld\n", ret);
1334
1335     /* trailing backslash characters */
1336     ret = RegCreateKeyExA(hkey_main, "Subkey4\\\\", 0, NULL, 0, KEY_NOTIFY, NULL, &hkey1, NULL);
1337     ok(ret == ERROR_SUCCESS, "RegCreateKeyExA failed with error %ld\n", ret);
1338     RegDeleteKeyA(hkey1, "");
1339     RegCloseKey(hkey1);
1340
1341     /* WOW64 flags - open an existing key */
1342     hkey1 = NULL;
1343     ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software", 0, NULL, 0, KEY_READ|KEY_WOW64_32KEY, NULL, &hkey1, NULL);
1344     ok(ret == ERROR_SUCCESS && hkey1 != NULL,
1345         "RegOpenKeyEx with KEY_WOW64_32KEY failed (err=%lu)\n", ret);
1346     RegCloseKey(hkey1);
1347
1348     hkey1 = NULL;
1349     ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software", 0, NULL, 0, KEY_READ|KEY_WOW64_64KEY, NULL, &hkey1, NULL);
1350     ok(ret == ERROR_SUCCESS && hkey1 != NULL,
1351         "RegOpenKeyEx with KEY_WOW64_64KEY failed (err=%lu)\n", ret);
1352     RegCloseKey(hkey1);
1353
1354     /* Try using WOW64 flags when opening a key with a DACL set to verify that
1355      * the registry access check is performed correctly. Redirection isn't
1356      * being tested, so the tests don't care about whether the process is
1357      * running under WOW64. */
1358     if (!has_wow64())
1359     {
1360         skip("WOW64 flags are not recognized\n");
1361         return;
1362     }
1363
1364     ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
1365                           KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &hkRoot32, NULL);
1366     if (limited_user)
1367         ok(ret == ERROR_ACCESS_DENIED && hkRoot32 == NULL,
1368            "RegCreateKeyEx with KEY_WOW64_32KEY failed (err=%ld)\n", ret);
1369     else
1370         ok(ret == ERROR_SUCCESS && hkRoot32 != NULL,
1371            "RegCreateKeyEx with KEY_WOW64_32KEY failed (err=%ld)\n", ret);
1372
1373     ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
1374                           KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &hkRoot64, NULL);
1375     if (limited_user)
1376         ok(ret == ERROR_ACCESS_DENIED && hkRoot64 == NULL,
1377            "RegCreateKeyEx with KEY_WOW64_64KEY failed (err=%ld)\n", ret);
1378     else
1379         ok(ret == ERROR_SUCCESS && hkRoot64 != NULL,
1380            "RegCreateKeyEx with KEY_WOW64_64KEY failed (err=%ld)\n", ret);
1381
1382     bRet = AllocateAndInitializeSid(&sid_authority, 1, SECURITY_WORLD_RID,
1383                                     0, 0, 0, 0, 0, 0, 0, &world_sid);
1384     ok(bRet == TRUE,
1385        "Expected AllocateAndInitializeSid to return TRUE, got %d, last error %lu\n", bRet, GetLastError());
1386
1387     access.grfAccessPermissions = GENERIC_ALL | STANDARD_RIGHTS_ALL;
1388     access.grfAccessMode = SET_ACCESS;
1389     access.grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
1390     access.Trustee.pMultipleTrustee = NULL;
1391     access.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
1392     access.Trustee.TrusteeForm = TRUSTEE_IS_SID;
1393     access.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
1394     access.Trustee.ptstrName = (char *)world_sid;
1395
1396     dwRet = SetEntriesInAclA(1, &access, NULL, &key_acl);
1397     ok(dwRet == ERROR_SUCCESS,
1398        "Expected SetEntriesInAclA to return ERROR_SUCCESS, got %lu, last error %lu\n", dwRet, GetLastError());
1399
1400     sd = malloc(SECURITY_DESCRIPTOR_MIN_LENGTH);
1401     bRet = InitializeSecurityDescriptor(sd, SECURITY_DESCRIPTOR_REVISION);
1402     ok(bRet == TRUE,
1403        "Expected InitializeSecurityDescriptor to return TRUE, got %d, last error %lu\n", bRet, GetLastError());
1404
1405     bRet = SetSecurityDescriptorDacl(sd, TRUE, key_acl, FALSE);
1406     ok(bRet == TRUE,
1407        "Expected SetSecurityDescriptorDacl to return TRUE, got %d, last error %lu\n", bRet, GetLastError());
1408
1409     if (limited_user)
1410     {
1411         skip("not enough privileges to modify HKLM\n");
1412     }
1413     else
1414     {
1415         ret = RegSetKeySecurity(hkRoot64, DACL_SECURITY_INFORMATION, sd);
1416         ok(ret == ERROR_SUCCESS,
1417            "Expected RegSetKeySecurity to return success, got error %lu\n", ret);
1418
1419         ret = RegSetKeySecurity(hkRoot32, DACL_SECURITY_INFORMATION, sd);
1420         ok(ret == ERROR_SUCCESS,
1421            "Expected RegSetKeySecurity to return success, got error %lu\n", ret);
1422
1423         hkey1 = NULL;
1424         ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
1425                               KEY_WOW64_64KEY | KEY_READ, NULL, &hkey1, NULL);
1426         ok(ret == ERROR_SUCCESS && hkey1 != NULL,
1427            "RegOpenKeyEx with KEY_WOW64_64KEY failed (err=%lu)\n", ret);
1428         RegCloseKey(hkey1);
1429
1430         hkey1 = NULL;
1431         ret = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
1432                               KEY_WOW64_32KEY | KEY_READ, NULL, &hkey1, NULL);
1433         ok(ret == ERROR_SUCCESS && hkey1 != NULL,
1434            "RegOpenKeyEx with KEY_WOW64_32KEY failed (err=%lu)\n", ret);
1435         RegCloseKey(hkey1);
1436     }
1437
1438     free(sd);
1439     LocalFree(key_acl);
1440     FreeSid(world_sid);
1441     RegDeleteKeyA(hkRoot64, "");
1442     RegCloseKey(hkRoot64);
1443     RegDeleteKeyA(hkRoot32, "");
1444     RegCloseKey(hkRoot32);
1445 }
1446
1447 static void test_reg_close_key(void)
1448 {
1449     DWORD ret = 0;
1450     HKEY hkHandle;
1451
1452     /* successfully close key
1453      * hkHandle remains changed after call to RegCloseKey
1454      */
1455     ret = RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkHandle);
1456     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1457     ret = RegCloseKey(hkHandle);
1458     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1459
1460     /* try to close the key twice */
1461     ret = RegCloseKey(hkHandle); /* Windows 95 doesn't mind. */
1462     ok(ret == ERROR_INVALID_HANDLE || ret == ERROR_SUCCESS,
1463        "expected ERROR_INVALID_HANDLE or ERROR_SUCCESS, got %ld\n", ret);
1464
1465     /* try to close a NULL handle */
1466     ret = RegCloseKey(NULL);
1467     ok(ret == ERROR_INVALID_HANDLE || ret == ERROR_BADKEY, /* Windows 95 returns BADKEY */
1468        "expected ERROR_INVALID_HANDLE or ERROR_BADKEY, got %ld\n", ret);
1469
1470     /* Check to see if we didn't potentially close our main handle, which could happen on win98 as
1471      * win98 doesn't give a new handle when the same key is opened.
1472      * Not re-opening will make some next tests fail.
1473      */
1474     if (hkey_main == hkHandle)
1475     {
1476         trace("The main handle is most likely closed, so re-opening\n");
1477         RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkey_main );
1478     }
1479 }
1480
1481 static void test_reg_delete_key(void)
1482 {
1483     DWORD ret;
1484     HKEY key;
1485
1486     ret = RegDeleteKeyA(hkey_main, NULL);
1487     ok(ret == ERROR_INVALID_PARAMETER, "got %ld\n", ret);
1488
1489     ret = RegCreateKeyA(hkey_main, "deleteme", &key);
1490     ok(ret == ERROR_SUCCESS, "Could not create key, got %ld\n", ret);
1491     ret = RegDeleteKeyA(key, "");
1492     ok(ret == ERROR_SUCCESS, "RegDeleteKeyA failed, got %ld\n", ret);
1493     RegCloseKey(key);
1494     ret = RegOpenKeyA(hkey_main, "deleteme", &key);
1495     ok(ret == ERROR_FILE_NOT_FOUND, "Key was not deleted, got %ld\n", ret);
1496     RegCloseKey(key);
1497
1498     /* Test deleting 32-bit keys */
1499     ret = RegCreateKeyExA(hkey_main, "deleteme", 0, NULL, 0, KEY_ALL_ACCESS | KEY_WOW64_32KEY, NULL, &key, NULL);
1500     ok(ret == ERROR_SUCCESS, "Could not create key, got %ld\n", ret);
1501     RegCloseKey(key);
1502
1503     ret = RegOpenKeyExA(hkey_main, "deleteme", 0, KEY_READ | KEY_WOW64_32KEY, &key);
1504     ok(ret == ERROR_SUCCESS, "Could not open key, got %ld\n", ret);
1505
1506     ret = RegDeleteKeyExA(key, "", KEY_WOW64_32KEY, 0);
1507     ok(ret == ERROR_SUCCESS, "RegDeleteKeyExA failed, got %ld\n", ret);
1508     RegCloseKey(key);
1509
1510     ret = RegOpenKeyExA(hkey_main, "deleteme", 0, KEY_READ | KEY_WOW64_32KEY, &key);
1511     ok(ret == ERROR_FILE_NOT_FOUND, "Key was not deleted, got %ld\n", ret);
1512     RegCloseKey(key);
1513 }
1514
1515 static BOOL set_privileges(LPCSTR privilege, BOOL set)
1516 {
1517     TOKEN_PRIVILEGES tp;
1518     HANDLE hToken;
1519     LUID luid;
1520
1521     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
1522         return FALSE;
1523
1524     if(!LookupPrivilegeValueA(NULL, privilege, &luid))
1525     {
1526         CloseHandle(hToken);
1527         return FALSE;
1528     }
1529
1530     tp.PrivilegeCount = 1;
1531     tp.Privileges[0].Luid = luid;
1532
1533     if (set)
1534         tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1535     else
1536         tp.Privileges[0].Attributes = 0;
1537
1538     AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
1539     if (GetLastError() != ERROR_SUCCESS)
1540     {
1541         CloseHandle(hToken);
1542         return FALSE;
1543     }
1544
1545     CloseHandle(hToken);
1546     return TRUE;
1547 }
1548
1549 static void delete_dir(const char *path)
1550 {
1551     char file[2 * MAX_PATH], *p;
1552     WIN32_FIND_DATAA fd;
1553     HANDLE hfind;
1554     BOOL r;
1555
1556     strcpy(file, path);
1557     p = file + strlen(file);
1558     p[0] = '\\';
1559     p[1] = '*';
1560     p[2] = 0;
1561     hfind = FindFirstFileA(file, &fd);
1562     if (hfind != INVALID_HANDLE_VALUE)
1563     {
1564         do
1565         {
1566             if (!strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, ".."))
1567                 continue;
1568
1569             strcpy(p + 1, fd.cFileName);
1570             r = DeleteFileA(file);
1571             ok(r, "DeleteFile failed on %s: %ld\n", debugstr_a(file), GetLastError());
1572         } while(FindNextFileA(hfind, &fd));
1573         FindClose(hfind);
1574     }
1575
1576     r = RemoveDirectoryA(path);
1577     ok(r, "RemoveDirectory failed: %ld\n", GetLastError());
1578 }
1579
1580 static void test_reg_load_key(void)
1581 {
1582     char saved_key[2 * MAX_PATH], buf[16], *p;
1583     UNICODE_STRING key_name;
1584     OBJECT_ATTRIBUTES attr;
1585     NTSTATUS status;
1586     DWORD ret, size;
1587     HKEY key;
1588
1589     if (!set_privileges(SE_RESTORE_NAME, TRUE) ||
1590         !set_privileges(SE_BACKUP_NAME, TRUE))
1591     {
1592         win_skip("Failed to set SE_RESTORE_NAME privileges, skipping tests\n");
1593         return;
1594     }
1595
1596     GetTempPathA(MAX_PATH, saved_key);
1597     strcat(saved_key, "\\wine_reg_test");
1598     CreateDirectoryA(saved_key, NULL);
1599     strcat(saved_key, "\\saved_key");
1600
1601     ret = RegSaveKeyA(hkey_main, saved_key, NULL);
1602     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1603
1604     ret = RegLoadKeyA(HKEY_LOCAL_MACHINE, "Test", saved_key);
1605     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1606
1607     ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Test", &key);
1608     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1609
1610     ret = RegSetValueExA(key, "test", 0, REG_SZ, (BYTE *)"value", 6);
1611     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1612
1613     /* try to unload though the key handle is live */
1614     pRtlInitUnicodeString(&key_name, L"\\REGISTRY\\Machine\\Test");
1615     InitializeObjectAttributes(&attr, &key_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1616     status = pNtUnloadKey(&attr);
1617     ok(status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08lx\n", status);
1618
1619     RegCloseKey(key);
1620
1621     ret = RegUnLoadKeyA(HKEY_LOCAL_MACHINE, "Test");
1622     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1623
1624     /* check if modifications are saved */
1625     ret = RegLoadKeyA(HKEY_LOCAL_MACHINE, "Test", saved_key);
1626     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1627
1628     ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Test", &key);
1629     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1630
1631     size = sizeof(buf);
1632     ret = RegGetValueA(key, NULL, "test", RRF_RT_REG_SZ, NULL, buf, &size);
1633     todo_wine ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1634     if (ret == ERROR_SUCCESS)
1635     {
1636         ok(size == 6, "size = %ld\n", size);
1637         ok(!strcmp(buf, "value"), "buf = %s\n", buf);
1638     }
1639
1640     RegCloseKey(key);
1641
1642     ret = RegUnLoadKeyA(HKEY_LOCAL_MACHINE, "Test");
1643     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1644
1645     pRtlInitUnicodeString(&key_name, L"\\REGISTRY\\User\\.Default");
1646     InitializeObjectAttributes(&attr, &key_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1647     status = pNtUnloadKey(&attr);
1648     ok(status == STATUS_ACCESS_DENIED, "expected STATUS_ACCESS_DENIED, got %08lx\n", status);
1649
1650     ret = RegUnLoadKeyA(HKEY_USERS, ".Default");
1651     ok(ret == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", ret);
1652
1653     set_privileges(SE_RESTORE_NAME, FALSE);
1654     set_privileges(SE_BACKUP_NAME, FALSE);
1655
1656     p = strrchr(saved_key, '\\');
1657     *p = 0;
1658     delete_dir(saved_key);
1659 }
1660
1661 /* Helper function to wait for a file blocked by the registry to be available */
1662 static void wait_file_available(char *path)
1663 {
1664     int attempts = 0;
1665     HANDLE file = NULL;
1666
1667     while (((file = CreateFileA(path, GENERIC_READ, 0, NULL,
1668                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
1669             && attempts++ < 10)
1670     {
1671         Sleep(200);
1672     }
1673     ok(file != INVALID_HANDLE_VALUE, "couldn't open file %s after 10 attempts error %ld.\n", path, GetLastError());
1674     CloseHandle(file);
1675 }
1676
1677 static void test_reg_load_app_key(void)
1678 {
1679     DWORD ret, size;
1680     char hivefilepath[2 * MAX_PATH], *p;
1681     const BYTE test_data[] = "Hello World";
1682     BYTE output[sizeof(test_data)];
1683     HKEY appkey = NULL;
1684
1685     if (!set_privileges(SE_BACKUP_NAME, TRUE))
1686     {
1687         win_skip("Failed to set SE_BACKUP_NAME privileges, skipping tests\n");
1688         return;
1689     }
1690
1691     GetTempPathA(MAX_PATH, hivefilepath);
1692     strcat(hivefilepath, "\\wine_reg_test");
1693     CreateDirectoryA(hivefilepath, NULL);
1694     strcat(hivefilepath, "\\saved_key");
1695
1696     ret = RegSaveKeyA(hkey_main, hivefilepath, NULL);
1697     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1698
1699     set_privileges(SE_BACKUP_NAME, FALSE);
1700
1701     /* Test simple key load */
1702     /* Check if the changes are saved */
1703     ret = RegLoadAppKeyA(hivefilepath, &appkey, KEY_READ | KEY_WRITE, 0, 0);
1704     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1705     ok(appkey != NULL, "got a null key\n");
1706
1707     ret = RegSetValueExA(appkey, "testkey", 0, REG_BINARY, test_data, sizeof(test_data));
1708     todo_wine ok(ret == ERROR_SUCCESS, "couldn't set key value %lx\n", ret);
1709     RegCloseKey(appkey);
1710
1711     wait_file_available(hivefilepath);
1712
1713     appkey = NULL;
1714     ret = RegLoadAppKeyA(hivefilepath, &appkey, KEY_READ, 0, 0);
1715     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1716     ok(appkey != NULL, "got a null key\n");
1717
1718     size = sizeof(test_data);
1719     memset(output, 0xff, sizeof(output));
1720     ret = RegGetValueA(appkey, NULL, "testkey", RRF_RT_REG_BINARY, NULL, output, &size);
1721     todo_wine ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
1722     ok(size == sizeof(test_data), "size doesn't match %ld != %ld\n", size, (DWORD)sizeof(test_data));
1723     todo_wine ok(!memcmp(test_data, output, sizeof(test_data)), "output is not what expected\n");
1724
1725     RegCloseKey(appkey);
1726
1727     wait_file_available(hivefilepath);
1728
1729     p = strrchr(hivefilepath, '\\');
1730     *p = 0;
1731     delete_dir(hivefilepath);
1732 }
1733
1734 /* tests that show that RegConnectRegistry and
1735    OpenSCManager accept computer names without the
1736    \\ prefix (what MSDN says).   */
1737 static void test_regconnectregistry( void)
1738 {
1739     CHAR compName[MAX_COMPUTERNAME_LENGTH + 1];
1740     CHAR netwName[MAX_COMPUTERNAME_LENGTH + 3]; /* 2 chars for double backslash */
1741     DWORD len = sizeof(compName) ;
1742     BOOL ret;
1743     LONG retl;
1744     HKEY hkey;
1745     SC_HANDLE schnd;
1746
1747     SetLastError(0xdeadbeef);
1748     ret = GetComputerNameA(compName, &len);
1749     ok( ret, "GetComputerName failed err = %ld\n", GetLastError());
1750     if( !ret) return;
1751
1752     lstrcpyA(netwName, "\\\\");
1753     lstrcpynA(netwName+2, compName, MAX_COMPUTERNAME_LENGTH + 1);
1754
1755     retl = RegConnectRegistryA( compName, HKEY_LOCAL_MACHINE, &hkey);
1756     ok( !retl, "RegConnectRegistryA failed err = %ld\n", retl);
1757     if( !retl) RegCloseKey( hkey);
1758
1759     retl = RegConnectRegistryA( netwName, HKEY_LOCAL_MACHINE, &hkey);
1760     ok( !retl, "RegConnectRegistryA failed err = %ld\n", retl);
1761     if( !retl) RegCloseKey( hkey);
1762
1763     SetLastError(0xdeadbeef);
1764     schnd = OpenSCManagerA( compName, NULL, GENERIC_READ);
1765     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1766     {
1767         win_skip("OpenSCManagerA is not implemented\n");
1768         return;
1769     }
1770
1771     ok( schnd != NULL, "OpenSCManagerA failed err = %ld\n", GetLastError());
1772     CloseServiceHandle( schnd);
1773
1774     SetLastError(0xdeadbeef);
1775     schnd = OpenSCManagerA( netwName, NULL, GENERIC_READ);
1776     ok( schnd != NULL, "OpenSCManagerA failed err = %ld\n", GetLastError());
1777     CloseServiceHandle( schnd);
1778
1779 }
1780
1781 static void test_reg_query_value(void)
1782 {
1783     HKEY subkey;
1784     CHAR val[MAX_PATH];
1785     WCHAR valW[5];
1786     LONG size, ret;
1787
1788     ret = RegCreateKeyA(hkey_main, "subkey", &subkey);
1789     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1790
1791     ret = RegSetValueA(subkey, NULL, REG_SZ, "data", 4);
1792     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1793
1794     /* try an invalid hkey */
1795     SetLastError(0xdeadbeef);
1796     size = MAX_PATH;
1797     ret = RegQueryValueA((HKEY)0xcafebabe, "subkey", val, &size);
1798     ok(ret == ERROR_INVALID_HANDLE ||
1799        ret == ERROR_BADKEY || /* Windows 98 returns BADKEY */
1800        ret == ERROR_ACCESS_DENIED, /* non-admin winxp */
1801        "Expected ERROR_INVALID_HANDLE or ERROR_BADKEY, got %ld\n", ret);
1802     ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
1803
1804     /* try a NULL hkey */
1805     SetLastError(0xdeadbeef);
1806     size = MAX_PATH;
1807     ret = RegQueryValueA(NULL, "subkey", val, &size);
1808     ok(ret == ERROR_INVALID_HANDLE || ret == ERROR_BADKEY, /* Windows 98 returns BADKEY */
1809        "Expected ERROR_INVALID_HANDLE or ERROR_BADKEY, got %ld\n", ret);
1810     ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
1811
1812     /* try a NULL value */
1813     size = MAX_PATH;
1814     ret = RegQueryValueA(hkey_main, "subkey", NULL, &size);
1815     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1816     ok(size == 5, "Expected 5, got %ld\n", size);
1817
1818     /* try a NULL size */
1819     SetLastError(0xdeadbeef);
1820     val[0] = '\0';
1821     ret = RegQueryValueA(hkey_main, "subkey", val, NULL);
1822     ok(ret == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", ret);
1823     ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
1824     ok(!val[0], "Expected val to be untouched, got %s\n", val);
1825
1826     /* try a NULL value and size */
1827     ret = RegQueryValueA(hkey_main, "subkey", NULL, NULL);
1828     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1829
1830     /* try a size too small */
1831     SetLastError(0xdeadbeef);
1832     val[0] = '\0';
1833     size = 1;
1834     ret = RegQueryValueA(hkey_main, "subkey", val, &size);
1835     ok(ret == ERROR_MORE_DATA, "Expected ERROR_MORE_DATA, got %ld\n", ret);
1836     ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
1837     ok(!val[0], "Expected val to be untouched, got %s\n", val);
1838     ok(size == 5, "Expected 5, got %ld\n", size);
1839
1840     /* successfully read the value using 'subkey' */
1841     size = MAX_PATH;
1842     ret = RegQueryValueA(hkey_main, "subkey", val, &size);
1843     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1844     ok(!lstrcmpA(val, "data"), "Expected 'data', got '%s'\n", val);
1845     ok(size == 5, "Expected 5, got %ld\n", size);
1846
1847     /* successfully read the value using the subkey key */
1848     size = MAX_PATH;
1849     ret = RegQueryValueA(subkey, NULL, val, &size);
1850     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1851     ok(!lstrcmpA(val, "data"), "Expected 'data', got '%s'\n", val);
1852     ok(size == 5, "Expected 5, got %ld\n", size);
1853
1854     /* unicode - try size too small */
1855     SetLastError(0xdeadbeef);
1856     valW[0] = '\0';
1857     size = 0;
1858     ret = RegQueryValueW(subkey, NULL, valW, &size);
1859     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1860     {
1861         win_skip("RegQueryValueW is not implemented\n");
1862         goto cleanup;
1863     }
1864     ok(ret == ERROR_MORE_DATA, "Expected ERROR_MORE_DATA, got %ld\n", ret);
1865     ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
1866     ok(!valW[0], "Expected valW to be untouched\n");
1867     ok(size == 10, "Got wrong size: %ld\n", size);
1868
1869     /* unicode - try size in WCHARS */
1870     SetLastError(0xdeadbeef);
1871     size = ARRAY_SIZE(valW);
1872     ret = RegQueryValueW(subkey, NULL, valW, &size);
1873     ok(ret == ERROR_MORE_DATA, "Expected ERROR_MORE_DATA, got %ld\n", ret);
1874     ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
1875     ok(!valW[0], "Expected valW to be untouched\n");
1876     ok(size == 10, "Got wrong size: %ld\n", size);
1877
1878     /* unicode - successfully read the value */
1879     size = sizeof(valW);
1880     ret = RegQueryValueW(subkey, NULL, valW, &size);
1881     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1882     ok(!lstrcmpW(valW, L"data"), "Got wrong value\n");
1883     ok(size == 10, "Got wrong size: %ld\n", size);
1884
1885     /* unicode - set the value without a NULL terminator */
1886     ret = RegSetValueW(subkey, NULL, REG_SZ, L"data", 8);
1887     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1888
1889     /* unicode - read the unterminated value, value is terminated for us */
1890     memset(valW, 'a', sizeof(valW));
1891     size = sizeof(valW);
1892     ret = RegQueryValueW(subkey, NULL, valW, &size);
1893     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1894     ok(!lstrcmpW(valW, L"data"), "Got wrong value\n");
1895     ok(size == 10, "Got wrong size: %ld\n", size);
1896
1897 cleanup:
1898     RegDeleteKeyA(subkey, "");
1899     RegCloseKey(subkey);
1900 }
1901
1902 static void test_reg_query_info(void)
1903 {
1904     HKEY subkey;
1905     HKEY subsubkey;
1906     LONG ret;
1907     char classbuffer[32];
1908     WCHAR classbufferW[32];
1909     char expectbuffer[32];
1910     WCHAR expectbufferW[32];
1911     char subkey_class[] = "subkey class";
1912     WCHAR subkey_classW[] = L"subkey class";
1913     char subsubkey_class[] = "subsubkey class";
1914     DWORD classlen;
1915     DWORD subkeys, maxsubkeylen, maxclasslen;
1916     DWORD values, maxvaluenamelen, maxvaluelen;
1917     DWORD sdlen;
1918     FILETIME lastwrite;
1919
1920     ret = RegCreateKeyExA(hkey_main, "subkey", 0, subkey_class, 0, KEY_ALL_ACCESS, NULL, &subkey, NULL);
1921     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1922
1923     /* all parameters NULL */
1924     ret = RegQueryInfoKeyA(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1925     ok(ret == ERROR_INVALID_HANDLE, "ret = %ld\n", ret);
1926
1927     ret = RegQueryInfoKeyW(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1928     ok(ret == ERROR_INVALID_HANDLE, "ret = %ld\n", ret);
1929
1930     /* not requesting any information */
1931     ret = RegQueryInfoKeyA(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1932     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
1933
1934     ret = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1935     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
1936
1937     /* class without length is invalid */
1938     memset(classbuffer, 0x55, sizeof(classbuffer));
1939     ret = RegQueryInfoKeyA(subkey, classbuffer, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1940     ok(ret == ERROR_INVALID_PARAMETER, "ret = %ld\n", ret);
1941     ok(classbuffer[0] == 0x55, "classbuffer[0] = 0x%x\n", classbuffer[0]);
1942
1943     memset(classbufferW, 0x55, sizeof(classbufferW));
1944     ret = RegQueryInfoKeyW(subkey, classbufferW, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1945     ok(ret == ERROR_INVALID_PARAMETER, "ret = %ld\n", ret);
1946     ok(classbufferW[0] == 0x5555, "classbufferW[0] = 0x%x\n", classbufferW[0]);
1947
1948     /* empty key */
1949     sdlen = classlen =0;
1950     ret = RegQueryInfoKeyA(subkey, NULL, &classlen, NULL, &subkeys, &maxsubkeylen, &maxclasslen, &values, &maxvaluenamelen, &maxvaluelen, &sdlen, &lastwrite);
1951     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
1952     ok(classlen == strlen(subkey_class), "classlen = %lu\n", classlen);
1953     ok(subkeys == 0, "subkeys = %lu\n", subkeys);
1954     ok(maxsubkeylen == 0, "maxsubkeylen = %lu\n", maxsubkeylen);
1955     ok(maxclasslen == 0, "maxclasslen = %lu\n", maxclasslen);
1956     ok(values == 0, "values = %lu\n", values);
1957     ok(maxvaluenamelen == 0, "maxvaluenamelen = %lu\n", maxvaluenamelen);
1958     ok(maxvaluelen == 0, "maxvaluelen = %lu\n", maxvaluelen);
1959     todo_wine ok(sdlen != 0, "sdlen = %lu\n", sdlen);
1960     ok(lastwrite.dwLowDateTime != 0, "lastwrite.dwLowDateTime = %lu\n", lastwrite.dwLowDateTime);
1961     ok(lastwrite.dwHighDateTime != 0, "lastwrite.dwHighDateTime = %lu\n", lastwrite.dwHighDateTime);
1962
1963     sdlen = classlen = 0;
1964     ret = RegQueryInfoKeyW(subkey, NULL, &classlen, NULL, &subkeys, &maxsubkeylen, &maxclasslen, &values, &maxvaluenamelen, &maxvaluelen, &sdlen, &lastwrite);
1965     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
1966     ok(classlen == strlen(subkey_class), "classlen = %lu\n", classlen);
1967     ok(subkeys == 0, "subkeys = %lu\n", subkeys);
1968     ok(maxsubkeylen == 0, "maxsubkeylen = %lu\n", maxsubkeylen);
1969     ok(maxclasslen == 0, "maxclasslen = %lu\n", maxclasslen);
1970     ok(values == 0, "values = %lu\n", values);
1971     ok(maxvaluenamelen == 0, "maxvaluenamelen = %lu\n", maxvaluenamelen);
1972     ok(maxvaluelen == 0, "maxvaluelen = %lu\n", maxvaluelen);
1973     todo_wine ok(sdlen != 0, "sdlen = %lu\n", sdlen);
1974     ok(lastwrite.dwLowDateTime != 0, "lastwrite.dwLowDateTime = %lu\n", lastwrite.dwLowDateTime);
1975     ok(lastwrite.dwHighDateTime != 0, "lastwrite.dwHighDateTime = %lu\n", lastwrite.dwHighDateTime);
1976
1977     ret = RegCreateKeyExA(subkey, "subsubkey", 0, subsubkey_class, 0, KEY_ALL_ACCESS, NULL, &subsubkey, NULL);
1978     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1979
1980     ret = RegSetValueExA(subkey, NULL, 0, REG_SZ, (const BYTE*)"data", 5);
1981     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
1982
1983     /* with subkey & default value */
1984     sdlen = classlen = 0;
1985     ret = RegQueryInfoKeyA(subkey, NULL, &classlen, NULL, &subkeys, &maxsubkeylen, &maxclasslen, &values, &maxvaluenamelen, &maxvaluelen, &sdlen, &lastwrite);
1986     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
1987     ok(classlen == strlen(subkey_class), "classlen = %lu\n", classlen);
1988     ok(subkeys == 1, "subkeys = %lu\n", subkeys);
1989     ok(maxsubkeylen == strlen("subsubkey"), "maxsubkeylen = %lu\n", maxsubkeylen);
1990     ok(maxclasslen == strlen(subsubkey_class), "maxclasslen = %lu\n", maxclasslen);
1991     ok(values == 1, "values = %lu\n", values);
1992     ok(maxvaluenamelen == 0, "maxvaluenamelen = %lu\n", maxvaluenamelen);
1993     ok(maxvaluelen == sizeof("data") * sizeof(WCHAR), "maxvaluelen = %lu\n", maxvaluelen);
1994     todo_wine ok(sdlen != 0, "sdlen = %lu\n", sdlen);
1995     ok(lastwrite.dwLowDateTime != 0, "lastwrite.dwLowDateTime = %lu\n", lastwrite.dwLowDateTime);
1996     ok(lastwrite.dwHighDateTime != 0, "lastwrite.dwHighDateTime = %lu\n", lastwrite.dwHighDateTime);
1997
1998     sdlen = classlen = 0;
1999     ret = RegQueryInfoKeyW(subkey, NULL, &classlen, NULL, &subkeys, &maxsubkeylen, &maxclasslen, &values, &maxvaluenamelen, &maxvaluelen, &sdlen, &lastwrite);
2000     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2001     ok(classlen == strlen(subkey_class), "classlen = %lu\n", classlen);
2002     ok(subkeys == 1, "subkeys = %lu\n", subkeys);
2003     ok(maxsubkeylen == strlen("subsubkey"), "maxsubkeylen = %lu\n", maxsubkeylen);
2004     ok(maxclasslen == strlen(subsubkey_class), "maxclasslen = %lu\n", maxclasslen);
2005     ok(values == 1, "values = %lu\n", values);
2006     ok(maxvaluenamelen == 0, "maxvaluenamelen = %lu\n", maxvaluenamelen);
2007     ok(maxvaluelen == sizeof("data") * sizeof(WCHAR), "maxvaluelen = %lu\n", maxvaluelen);
2008     todo_wine ok(sdlen != 0, "sdlen = %lu\n", sdlen);
2009     ok(lastwrite.dwLowDateTime != 0, "lastwrite.dwLowDateTime = %lu\n", lastwrite.dwLowDateTime);
2010     ok(lastwrite.dwHighDateTime != 0, "lastwrite.dwHighDateTime = %lu\n", lastwrite.dwHighDateTime);
2011
2012     ret = RegSetValueExA(subkey, "value one", 0, REG_SZ, (const BYTE*)"first value data", 17);
2013     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2014
2015     ret = RegSetValueExA(subkey, "value 2", 0, REG_SZ, (const BYTE*)"second value data", 18);
2016     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2017
2018     /* with named value */
2019     classlen = 0;
2020     ret = RegQueryInfoKeyA(subkey, NULL, &classlen, NULL, &subkeys, &maxsubkeylen, &maxclasslen, &values, &maxvaluenamelen, &maxvaluelen, &sdlen, &lastwrite);
2021     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2022     ok(values == 3, "values = %lu\n", values);
2023     ok(maxvaluenamelen == strlen("value one"), "maxvaluenamelen = %lu\n", maxvaluenamelen);
2024     ok(maxvaluelen == sizeof("second value data") * sizeof(WCHAR), "maxvaluelen = %lu\n", maxvaluelen);
2025
2026     classlen = 0;
2027     ret = RegQueryInfoKeyW(subkey, NULL, &classlen, NULL, &subkeys, &maxsubkeylen, &maxclasslen, &values, &maxvaluenamelen, &maxvaluelen, &sdlen, &lastwrite);
2028     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2029     ok(values == 3, "values = %lu\n", values);
2030     ok(maxvaluenamelen == strlen("value one"), "maxvaluenamelen = %lu\n", maxvaluenamelen);
2031     ok(maxvaluelen == sizeof("second value data") * sizeof(WCHAR), "maxvaluelen = %lu\n", maxvaluelen);
2032
2033     /* class name with zero size buffer */
2034     memset(classbuffer, 0x55, sizeof(classbuffer));
2035     classlen = 0;
2036     ret = RegQueryInfoKeyA(subkey, classbuffer, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2037     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2038     todo_wine ok(classlen == 0, "classlen = %lu\n", classlen);
2039     memset(expectbuffer, 0x55, sizeof(expectbuffer));
2040     ok(!memcmp(classbuffer, expectbuffer, sizeof(classbuffer)), "classbuffer was modified\n");
2041
2042     memset(classbufferW, 0x55, sizeof(classbufferW));
2043     classlen = 0;
2044     ret = RegQueryInfoKeyW(subkey, classbufferW, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2045     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2046     todo_wine ok(classlen == 0, "classlen = %lu\n", classlen);
2047     memset(expectbufferW, 0x55, sizeof(expectbufferW));
2048     ok(!memcmp(classbufferW, expectbufferW, sizeof(classbufferW)), "classbufferW was modified\n");
2049
2050     /* class name with one char buffer */
2051     memset(classbuffer, 0x55, sizeof(classbuffer));
2052     classlen = 1;
2053     ret = RegQueryInfoKeyA(subkey, classbuffer, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2054     ok(ret == ERROR_MORE_DATA, "ret = %ld\n", ret);
2055     ok(classlen == 0, "classlen = %lu\n", classlen);
2056     memset(expectbuffer, 0x55, sizeof(expectbuffer));
2057     expectbuffer[0] = 0;
2058     ok(!memcmp(classbuffer, expectbuffer, sizeof(classbuffer)), "classbuffer was modified\n");
2059
2060     memset(classbufferW, 0x55, sizeof(classbufferW));
2061     classlen = 1;
2062     ret = RegQueryInfoKeyW(subkey, classbufferW, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2063     /* failure-code changed to ERROR_MORE_DATA in recent win10  */
2064     ok((ret == ERROR_INSUFFICIENT_BUFFER) || (ret == ERROR_MORE_DATA), "ret = %ld\n", ret);
2065     ok(classlen == 0 /* win8 */ ||
2066        classlen == strlen(subkey_class), "classlen = %lu\n", classlen);
2067     memset(expectbufferW, 0x55, sizeof(expectbufferW));
2068     ok(!memcmp(classbufferW, expectbufferW, sizeof(classbufferW)), "classbufferW was modified\n");
2069
2070     /* class name with buffer one char too small */
2071     memset(classbuffer, 0x55, sizeof(classbuffer));
2072     classlen = sizeof(subkey_class) - 1;
2073     ret = RegQueryInfoKeyA(subkey, classbuffer, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2074     ok(ret == ERROR_MORE_DATA, "ret = %ld\n", ret);
2075     ok(classlen == sizeof(subkey_class) - 2, "classlen = %lu\n", classlen);
2076     memset(expectbuffer, 0x55, sizeof(expectbuffer));
2077     strcpy(expectbuffer, subkey_class);
2078     expectbuffer[sizeof(subkey_class) - 2] = 0;
2079     expectbuffer[sizeof(subkey_class) - 1] = 0x55;
2080     ok(!memcmp(classbuffer, expectbuffer, sizeof(classbuffer)),
2081        "classbuffer = %.*s, expected %s\n",
2082        (int)sizeof(classbuffer), classbuffer, expectbuffer);
2083
2084     memset(classbufferW, 0x55, sizeof(classbufferW));
2085     classlen = sizeof(subkey_class) - 1;
2086     ret = RegQueryInfoKeyW(subkey, classbufferW, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2087     ok(ret == ERROR_INSUFFICIENT_BUFFER, "ret = %ld\n", ret);
2088     ok(classlen == sizeof(subkey_class) - 2 /* win8 */ ||
2089        classlen == strlen(subkey_class), "classlen = %lu\n", classlen);
2090     memset(expectbufferW, 0x55, sizeof(expectbufferW));
2091     ok(!memcmp(classbufferW, expectbufferW, sizeof(classbufferW)), "classbufferW was modified\n");
2092
2093     /* class name with large enough buffer */
2094     memset(classbuffer, 0x55, sizeof(classbuffer));
2095     classlen = sizeof(subkey_class);
2096     ret = RegQueryInfoKeyA(subkey, classbuffer, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2097     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2098     ok(classlen == sizeof(subkey_class) - 1, "classlen = %lu\n", classlen);
2099     memset(expectbuffer, 0x55, sizeof(expectbuffer));
2100     strcpy(expectbuffer, subkey_class);
2101     ok(!memcmp(classbuffer, expectbuffer, sizeof(classbuffer)),
2102        "classbuffer = \"%.*s\", expected %s\n",
2103        (int)sizeof(classbuffer), classbuffer, expectbuffer);
2104
2105     memset(classbuffer, 0x55, sizeof(classbuffer));
2106     classlen = 0xdeadbeef;
2107     ret = RegQueryInfoKeyA(subkey, classbuffer, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2108     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2109     ok(classlen == sizeof(subkey_class) - 1, "classlen = %lu\n", classlen);
2110     memset(expectbuffer, 0x55, sizeof(expectbuffer));
2111     strcpy(expectbuffer, subkey_class);
2112     ok(!memcmp(classbuffer, expectbuffer, sizeof(classbuffer)),
2113        "classbuffer = \"%.*s\", expected %s\n",
2114        (int)sizeof(classbuffer), classbuffer, expectbuffer);
2115
2116     memset(classbufferW, 0x55, sizeof(classbufferW));
2117     classlen = sizeof(subkey_class);
2118     ret = RegQueryInfoKeyW(subkey, classbufferW, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2119     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2120     ok(classlen == sizeof(subkey_class) - 1, "classlen = %lu\n", classlen);
2121     memset(expectbufferW, 0x55, sizeof(expectbufferW));
2122     lstrcpyW(expectbufferW, subkey_classW);
2123     ok(!memcmp(classbufferW, expectbufferW, sizeof(classbufferW)),
2124        "classbufferW = %s, expected %s\n",
2125        wine_dbgstr_wn(classbufferW, ARRAY_SIZE(classbufferW)), wine_dbgstr_w(expectbufferW));
2126
2127     memset(classbufferW, 0x55, sizeof(classbufferW));
2128     classlen = 0xdeadbeef;
2129     ret = RegQueryInfoKeyW(subkey, classbufferW, &classlen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2130     ok(ret == ERROR_SUCCESS, "ret = %ld\n", ret);
2131     ok(classlen == sizeof(subkey_class) - 1, "classlen = %lu\n", classlen);
2132     memset(expectbufferW, 0x55, sizeof(expectbufferW));
2133     lstrcpyW(expectbufferW, subkey_classW);
2134     ok(!memcmp(classbufferW, expectbufferW, sizeof(classbufferW)),
2135        "classbufferW = %s, expected %s\n",
2136        wine_dbgstr_wn(classbufferW, ARRAY_SIZE(classbufferW)), wine_dbgstr_w(expectbufferW));
2137
2138     RegDeleteKeyA(subsubkey, "");
2139     RegCloseKey(subsubkey);
2140     RegDeleteKeyA(subkey, "");
2141     RegCloseKey(subkey);
2142 }
2143
2144 static void test_string_termination(void)
2145 {
2146     HKEY subkey;
2147     LSTATUS ret;
2148     static const char string[] = "FullString";
2149     char name[11];
2150     BYTE buffer[11];
2151     DWORD insize, outsize, nsize;
2152
2153     ret = RegCreateKeyA(hkey_main, "string_termination", &subkey);
2154     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2155
2156     /* Off-by-one RegSetValueExA -> adds a trailing '\0'! */
2157     insize=sizeof(string)-1;
2158     ret = RegSetValueExA(subkey, "stringtest", 0, REG_SZ, (BYTE*)string, insize);
2159     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", ret);
2160     outsize=insize;
2161     ret = RegQueryValueExA(subkey, "stringtest", NULL, NULL, buffer, &outsize);
2162     ok(ret == ERROR_MORE_DATA, "RegQueryValueExA returned: %ld\n", ret);
2163
2164     /* Off-by-two RegSetValueExA -> no trailing '\0' */
2165     insize=sizeof(string)-2;
2166     ret = RegSetValueExA(subkey, "stringtest", 0, REG_SZ, (BYTE*)string, insize);
2167     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", ret);
2168     outsize=0;
2169     ret = RegQueryValueExA(subkey, "stringtest", NULL, NULL, NULL, &outsize);
2170     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2171     ok(outsize == insize, "wrong size %lu != %lu\n", outsize, insize);
2172
2173     /* RegQueryValueExA may return a string with no trailing '\0' */
2174     outsize=insize;
2175     memset(buffer, 0xbd, sizeof(buffer));
2176     ret = RegQueryValueExA(subkey, "stringtest", NULL, NULL, buffer, &outsize);
2177     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2178     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2179     ok(memcmp(buffer, string, outsize) == 0, "bad string: %s/%lu != %s\n",
2180        debugstr_an((char*)buffer, outsize), outsize, string);
2181     ok(buffer[insize] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2182
2183     /* RegQueryValueExA adds a trailing '\0' if there is room */
2184     outsize=insize+1;
2185     memset(buffer, 0xbd, sizeof(buffer));
2186     ret = RegQueryValueExA(subkey, "stringtest", NULL, NULL, buffer, &outsize);
2187     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2188     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2189     ok(memcmp(buffer, string, outsize) == 0, "bad string: %s/%lu != %s\n",
2190        debugstr_an((char*)buffer, outsize), outsize, string);
2191     ok(buffer[insize] == 0, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2192
2193     /* RegEnumValueA may return a string with no trailing '\0' */
2194     outsize=insize;
2195     memset(buffer, 0xbd, sizeof(buffer));
2196     nsize=sizeof(name);
2197     ret = RegEnumValueA(subkey, 0, name, &nsize, NULL, NULL, buffer, &outsize);
2198     ok(ret == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", ret);
2199     ok(strcmp(name, "stringtest") == 0, "wrong name: %s\n", name);
2200     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2201     ok(memcmp(buffer, string, outsize) == 0, "bad string: %s/%lu != %s\n",
2202        debugstr_an((char*)buffer, outsize), outsize, string);
2203     ok(buffer[insize] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2204
2205     /* RegEnumValueA adds a trailing '\0' if there is room */
2206     outsize=insize+1;
2207     memset(buffer, 0xbd, sizeof(buffer));
2208     nsize=sizeof(name);
2209     ret = RegEnumValueA(subkey, 0, name, &nsize, NULL, NULL, buffer, &outsize);
2210     ok(ret == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", ret);
2211     ok(strcmp(name, "stringtest") == 0, "wrong name: %s\n", name);
2212     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2213     ok(memcmp(buffer, string, outsize) == 0, "bad string: %s/%lu != %s\n",
2214        debugstr_an((char*)buffer, outsize), outsize, string);
2215     ok(buffer[insize] == 0, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2216
2217     /* RegGetValueA always adds the trailing '\0' */
2218     if (pRegGetValueA)
2219     {
2220         outsize = insize;
2221         ret = pRegGetValueA(subkey, NULL, "stringtest", RRF_RT_REG_SZ, NULL, buffer, &outsize);
2222         ok(ret == ERROR_MORE_DATA, "RegGetValueA returned: %ld\n", ret);
2223         ok(outsize == insize + 1, "wrong size: %lu != %lu\n", outsize, insize + 1);
2224         memset(buffer, 0xbd, sizeof(buffer));
2225         ret = pRegGetValueA(subkey, NULL, "stringtest", RRF_RT_REG_SZ, NULL, buffer, &outsize);
2226         ok(ret == ERROR_SUCCESS, "RegGetValueA returned: %ld\n", ret);
2227         ok(outsize == insize + 1, "wrong size: %lu != %lu\n", outsize, insize + 1);
2228         ok(memcmp(buffer, string, insize) == 0, "bad string: %s/%lu != %s\n",
2229            debugstr_an((char*)buffer, insize), insize, string);
2230         ok(buffer[insize] == 0, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2231     }
2232
2233     RegDeleteKeyA(subkey, "");
2234     RegCloseKey(subkey);
2235 }
2236
2237 static void test_multistring_termination(void)
2238 {
2239     HKEY subkey;
2240     LSTATUS ret;
2241     static const char multistring[] = "Aa\0Bb\0Cc\0";
2242     char name[sizeof("multistringtest")];
2243     BYTE buffer[sizeof(multistring)];
2244     DWORD insize, outsize, nsize;
2245
2246     ret = RegCreateKeyA(hkey_main, "multistring_termination", &subkey);
2247     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2248
2249     /* Off-by-one RegSetValueExA -> only one trailing '\0' */
2250     insize = sizeof(multistring) - 1;
2251     ret = RegSetValueExA(subkey, "multistringtest", 0, REG_SZ, (BYTE*)multistring, insize);
2252     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", ret);
2253     outsize = 0;
2254     ret = RegQueryValueExA(subkey, "multistringtest", NULL, NULL, NULL, &outsize);
2255     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2256     ok(outsize == insize, "wrong size %lu != %lu\n", outsize, insize);
2257
2258     /* Off-by-two RegSetValueExA -> adds a trailing '\0'! */
2259     insize = sizeof(multistring) - 2;
2260     ret = RegSetValueExA(subkey, "multistringtest", 0, REG_SZ, (BYTE*)multistring, insize);
2261     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", ret);
2262     outsize = insize;
2263     ret = RegQueryValueExA(subkey, "multistringtest", NULL, NULL, buffer, &outsize);
2264     ok(ret == ERROR_MORE_DATA, "RegQueryValueExA returned: %ld\n", ret);
2265
2266     /* Off-by-three RegSetValueExA -> no trailing '\0' */
2267     insize = sizeof(multistring) - 3;
2268     ret = RegSetValueExA(subkey, "multistringtest", 0, REG_SZ, (BYTE*)multistring, insize);
2269     ok(ret == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", ret);
2270     outsize = 0;
2271     ret = RegQueryValueExA(subkey, "multistringtest", NULL, NULL, NULL, &outsize);
2272     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2273     ok(outsize == insize, "wrong size %lu != %lu\n", outsize, insize);
2274
2275     /* RegQueryValueExA may return a multistring with no trailing '\0' */
2276     outsize = insize;
2277     memset(buffer, 0xbd, sizeof(buffer));
2278     ret = RegQueryValueExA(subkey, "multistringtest", NULL, NULL, buffer, &outsize);
2279     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2280     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2281     ok(memcmp(buffer, multistring, outsize) == 0, "bad multistring: %s/%lu != %s\n",
2282        debugstr_an((char*)buffer, outsize), outsize, multistring);
2283     ok(buffer[insize] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2284
2285     /* RegQueryValueExA adds one trailing '\0' if there is room */
2286     outsize = insize + 1;
2287     memset(buffer, 0xbd, sizeof(buffer));
2288     ret = RegQueryValueExA(subkey, "multistringtest", NULL, NULL, buffer, &outsize);
2289     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2290     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2291     ok(memcmp(buffer, multistring, outsize) == 0, "bad multistring: %s/%lu != %s\n",
2292        debugstr_an((char*)buffer, outsize), outsize, multistring);
2293     ok(buffer[insize] == 0, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2294
2295     /* RegQueryValueExA doesn't add a second trailing '\0' even if there is room */
2296     outsize = insize + 2;
2297     memset(buffer, 0xbd, sizeof(buffer));
2298     ret = RegQueryValueExA(subkey, "multistringtest", NULL, NULL, buffer, &outsize);
2299     ok(ret == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", ret);
2300     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2301     ok(memcmp(buffer, multistring, outsize) == 0, "bad multistring: %s/%lu != %s\n",
2302        debugstr_an((char*)buffer, outsize), outsize, multistring);
2303     ok(buffer[insize + 1] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize + 1]);
2304
2305     /* RegEnumValueA may return a multistring with no trailing '\0' */
2306     outsize = insize;
2307     memset(buffer, 0xbd, sizeof(buffer));
2308     nsize = sizeof(name);
2309     ret = RegEnumValueA(subkey, 0, name, &nsize, NULL, NULL, buffer, &outsize);
2310     ok(ret == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", ret);
2311     ok(strcmp(name, "multistringtest") == 0, "wrong name: %s\n", name);
2312     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2313     ok(memcmp(buffer, multistring, outsize) == 0, "bad multistring: %s/%lu != %s\n",
2314        debugstr_an((char*)buffer, outsize), outsize, multistring);
2315     ok(buffer[insize] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2316
2317     /* RegEnumValueA adds one trailing '\0' even if there's room for two */
2318     outsize = insize + 2;
2319     memset(buffer, 0xbd, sizeof(buffer));
2320     nsize = sizeof(name);
2321     ret = RegEnumValueA(subkey, 0, name, &nsize, NULL, NULL, buffer, &outsize);
2322     ok(ret == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", ret);
2323     ok(strcmp(name, "multistringtest") == 0, "wrong name: %s\n", name);
2324     ok(outsize == insize, "wrong size: %lu != %lu\n", outsize, insize);
2325     ok(memcmp(buffer, multistring, outsize) == 0, "bad multistring: %s/%lu != %s\n",
2326        debugstr_an((char*)buffer, outsize), outsize, multistring);
2327     ok(buffer[insize] == 0, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2328     ok(buffer[insize + 1] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize]);
2329
2330     /* RegGetValueA always adds one trailing '\0' even if there's room for two */
2331     if (pRegGetValueA)
2332     {
2333         outsize = insize;
2334         ret = pRegGetValueA(subkey, NULL, "multistringtest", RRF_RT_REG_SZ, NULL, buffer, &outsize);
2335         ok(ret == ERROR_MORE_DATA, "RegGetValueA returned: %ld\n", ret);
2336         ok(outsize == insize + 1, "wrong size: %lu != %lu\n", outsize, insize + 1);
2337         outsize = insize + 2;
2338         memset(buffer, 0xbd, sizeof(buffer));
2339         ret = pRegGetValueA(subkey, NULL, "multistringtest", RRF_RT_REG_SZ, NULL, buffer, &outsize);
2340         ok(ret == ERROR_SUCCESS, "RegGetValueA returned: %ld\n", ret);
2341         ok(outsize == insize + 1, "wrong size: %lu != %lu\n", outsize, insize + 1);
2342         ok(buffer[insize] == 0, "buffer overflow at %lu %02x\n", insize, buffer[insize + 1]);
2343         ok(buffer[insize + 1] == 0xbd, "buffer overflow at %lu %02x\n", insize, buffer[insize + 1]);
2344     }
2345
2346     RegDeleteKeyA(subkey, "");
2347     RegCloseKey(subkey);
2348 }
2349
2350 static void test_reg_copy_tree(void)
2351 {
2352     HKEY src, dst, subkey;
2353     CHAR buffer[MAX_PATH];
2354     DWORD dwsize, type;
2355     LONG size, ret;
2356
2357     if (!pRegCopyTreeA)
2358     {
2359         win_skip("Skipping RegCopyTreeA tests, function not present\n");
2360         return;
2361     }
2362
2363     ret = RegCreateKeyA(hkey_main, "src", &src);
2364     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2365     ret = RegCreateKeyA(hkey_main, "dst", &dst);
2366     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2367
2368     /* Copy nonexistent subkey */
2369     ret = pRegCopyTreeA(src, "nonexistent_subkey", dst);
2370     ok(ret == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
2371
2372     /*  Create test keys and values */
2373     ret = RegSetValueA(src, NULL, REG_SZ, "data", 4);
2374     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2375     ret = RegSetValueExA(src, "value", 0, REG_SZ, (const BYTE *)"data2", 5);
2376     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2377
2378     ret = RegCreateKeyA(src, "subkey2", &subkey);
2379     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2380     ret = RegSetValueA(subkey, NULL, REG_SZ, "data3", 5);
2381     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2382     ret = RegSetValueExA(subkey, "value", 0, REG_SZ, (const BYTE *)"data4", 5);
2383     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2384     ret = RegCloseKey(subkey);
2385     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2386
2387     ret = RegCreateKeyA(src, "subkey3", &subkey);
2388     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2389     ret = RegCloseKey(subkey);
2390     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2391
2392     /* Copy subkey */
2393     ret = pRegCopyTreeA(src, "subkey2", dst);
2394     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2395
2396     size = MAX_PATH;
2397     ret = RegQueryValueA(dst, NULL, buffer, &size);
2398     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2399     ok(!strcmp(buffer, "data3"), "Expected 'data3', got '%s'\n", buffer);
2400
2401     dwsize = MAX_PATH;
2402     ret = RegQueryValueExA(dst, "value", NULL, &type, (BYTE *)buffer, &dwsize);
2403     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2404     ok(type == REG_SZ, "Expected REG_SZ, got %lu\n", type);
2405     ok(!strcmp(buffer, "data4"), "Expected 'data4', got '%s'\n", buffer);
2406
2407     /* Copy full tree */
2408     ret = pRegCopyTreeA(src, NULL, dst);
2409     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2410
2411     size = MAX_PATH;
2412     ret = RegQueryValueA(dst, NULL, buffer, &size);
2413     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2414     ok(!strcmp(buffer, "data"), "Expected 'data', got '%s'\n", buffer);
2415
2416     dwsize = MAX_PATH;
2417     ret = RegQueryValueExA(dst, "value", NULL, &type, (BYTE *)buffer, &dwsize);
2418     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2419     ok(type == REG_SZ, "Expected REG_SZ, got %lu\n", type);
2420     ok(!strcmp(buffer, "data2"), "Expected 'data2', got '%s'\n", buffer);
2421
2422     ret = RegOpenKeyA(dst, "subkey2", &subkey);
2423     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2424     size = MAX_PATH;
2425     ret = RegQueryValueA(subkey, NULL, buffer, &size);
2426     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2427     ok(!strcmp(buffer, "data3"), "Expected 'data3', got '%s'\n", buffer);
2428     dwsize = MAX_PATH;
2429     ret = RegQueryValueExA(subkey, "value", NULL, &type, (BYTE *)buffer, &dwsize);
2430     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2431     ok(type == REG_SZ, "Expected REG_SZ, got %lu\n", type);
2432     ok(!strcmp(buffer, "data4"), "Expected 'data4', got '%s'\n", buffer);
2433     ret = RegCloseKey(subkey);
2434     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2435
2436     ret = RegOpenKeyA(dst, "subkey3", &subkey);
2437     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2438     ret = RegCloseKey(subkey);
2439     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2440
2441     delete_key(src);
2442     delete_key(dst);
2443 }
2444
2445 static void test_reg_delete_tree(void)
2446 {
2447     CHAR buffer[MAX_PATH];
2448     HKEY subkey, subkey2;
2449     DWORD dwsize, type;
2450     LONG size, ret;
2451
2452     if(!pRegDeleteTreeA) {
2453         win_skip("Skipping RegDeleteTreeA tests, function not present\n");
2454         return;
2455     }
2456
2457     ret = RegCreateKeyA(hkey_main, "subkey", &subkey);
2458     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2459     ret = RegCreateKeyA(subkey, "subkey2", &subkey2);
2460     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2461     ret = RegSetValueA(subkey, NULL, REG_SZ, "data", 4);
2462     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2463     ret = RegSetValueA(subkey2, NULL, REG_SZ, "data2", 5);
2464     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2465     ret = RegCloseKey(subkey2);
2466     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2467
2468     ret = pRegDeleteTreeA(subkey, "subkey2");
2469     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2470     ok(RegOpenKeyA(subkey, "subkey2", &subkey2),
2471         "subkey2 was not deleted\n");
2472     size = MAX_PATH;
2473     ok(!RegQueryValueA(subkey, NULL, buffer, &size),
2474         "Default value of subkey no longer present\n");
2475
2476     ret = RegCreateKeyA(subkey, "subkey2", &subkey2);
2477     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2478     ret = RegCloseKey(subkey2);
2479     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2480     ret = pRegDeleteTreeA(hkey_main, "subkey\\subkey2");
2481     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2482     ok(RegOpenKeyA(subkey, "subkey2", &subkey2),
2483         "subkey2 was not deleted\n");
2484     ok(!RegQueryValueA(subkey, NULL, buffer, &size),
2485         "Default value of subkey no longer present\n");
2486
2487     ret = RegCreateKeyA(subkey, "subkey2", &subkey2);
2488     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2489     ret = RegCloseKey(subkey2);
2490     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2491     ret = RegCreateKeyA(subkey, "subkey3", &subkey2);
2492     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2493     ret = RegCloseKey(subkey2);
2494     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2495     ret = RegSetValueA(subkey, NULL, REG_SZ, "data", 4);
2496     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2497     ret = RegSetValueExA(subkey, "value", 0, REG_SZ, (const BYTE *)"data2", 5);
2498     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2499     ret = pRegDeleteTreeA(subkey, NULL);
2500     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2501     ok(!RegOpenKeyA(hkey_main, "subkey", &subkey),
2502         "subkey was deleted\n");
2503     ok(RegOpenKeyA(subkey, "subkey2", &subkey2),
2504         "subkey2 was not deleted\n");
2505     ok(RegOpenKeyA(subkey, "subkey3", &subkey2),
2506         "subkey3 was not deleted\n");
2507     size = MAX_PATH;
2508     ret = RegQueryValueA(subkey, NULL, buffer, &size);
2509     ok(ret == ERROR_SUCCESS,
2510         "Default value of subkey is not present\n");
2511     ok(!buffer[0], "Expected length 0 got length %u(%s)\n", lstrlenA(buffer), buffer);
2512     dwsize = MAX_PATH;
2513     ok(RegQueryValueExA(subkey, "value", NULL, &type, (BYTE *)buffer, &dwsize),
2514         "Value is still present\n");
2515     ret = RegCloseKey(subkey);
2516     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2517
2518     ret = RegOpenKeyA(hkey_main, "subkey", &subkey);
2519     ok(ret == ERROR_SUCCESS, "subkey was deleted\n");
2520     ret = pRegDeleteTreeA(subkey, "");
2521     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2522     ret = RegCloseKey(subkey);
2523     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2524
2525     ret = RegOpenKeyA(hkey_main, "subkey", &subkey);
2526     ok(ret == ERROR_SUCCESS, "subkey was deleted\n");
2527     ret = RegCloseKey(subkey);
2528     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", ret);
2529
2530     ret = pRegDeleteTreeA(hkey_main, "not-here");
2531     ok(ret == ERROR_FILE_NOT_FOUND,
2532         "Expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
2533 }
2534
2535 static void test_rw_order(void)
2536 {
2537     HKEY hKey;
2538     DWORD dw = 0;
2539     static const char keyname[] = "test_rw_order";
2540     char value_buf[2];
2541     DWORD values, value_len, value_name_max_len;
2542     LSTATUS ret;
2543
2544     RegDeleteKeyA(HKEY_CURRENT_USER, keyname);
2545     ret = RegCreateKeyA(HKEY_CURRENT_USER, keyname, &hKey);
2546     if(ret != ERROR_SUCCESS) {
2547         skip("Couldn't create key. Skipping.\n");
2548         return;
2549     }
2550
2551     ok(!RegSetValueExA(hKey, "A", 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw)),
2552        "RegSetValueExA for value \"A\" failed\n");
2553     ok(!RegSetValueExA(hKey, "C", 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw)),
2554        "RegSetValueExA for value \"C\" failed\n");
2555     ok(!RegSetValueExA(hKey, "D", 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw)),
2556        "RegSetValueExA for value \"D\" failed\n");
2557     ok(!RegSetValueExA(hKey, "B", 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw)),
2558        "RegSetValueExA for value \"B\" failed\n");
2559
2560     ok(!RegQueryInfoKeyA(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &values,
2561        &value_name_max_len, NULL, NULL, NULL), "RegQueryInfoKeyA failed\n");
2562     ok(values == 4, "Expected 4 values, got %lu\n", values);
2563
2564     /* Value enumeration preserves RegSetValueEx call order */
2565     value_len = 2;
2566     ok(!RegEnumValueA(hKey, 0, value_buf, &value_len, NULL, NULL, NULL, NULL), "RegEnumValueA failed\n");
2567     ok(strcmp(value_buf, "A") == 0, "Expected name \"A\", got %s\n", value_buf);
2568     value_len = 2;
2569     ok(!RegEnumValueA(hKey, 1, value_buf, &value_len, NULL, NULL, NULL, NULL), "RegEnumValueA failed\n");
2570     todo_wine ok(strcmp(value_buf, "C") == 0, "Expected name \"C\", got %s\n", value_buf);
2571     value_len = 2;
2572     ok(!RegEnumValueA(hKey, 2, value_buf, &value_len, NULL, NULL, NULL, NULL), "RegEnumValueA failed\n");
2573     todo_wine ok(strcmp(value_buf, "D") == 0, "Expected name \"D\", got %s\n", value_buf);
2574     value_len = 2;
2575     ok(!RegEnumValueA(hKey, 3, value_buf, &value_len, NULL, NULL, NULL, NULL), "RegEnumValueA failed\n");
2576     todo_wine ok(strcmp(value_buf, "B") == 0, "Expected name \"B\", got %s\n", value_buf);
2577
2578     ok(!RegDeleteKeyA(HKEY_CURRENT_USER, keyname), "Failed to delete key\n");
2579 }
2580
2581 static void test_symlinks(void)
2582 {
2583     static const WCHAR targetW[] = L"\\Software\\Wine\\Test\\target";
2584     BYTE buffer[1024];
2585     UNICODE_STRING target_str;
2586     WCHAR *target;
2587     HKEY key, link;
2588     NTSTATUS status;
2589     DWORD target_len, type, len, dw, err;
2590
2591     if (!pRtlFormatCurrentUserKeyPath || !pNtDeleteKey)
2592     {
2593         win_skip( "Can't perform symlink tests\n" );
2594         return;
2595     }
2596
2597     pRtlFormatCurrentUserKeyPath( &target_str );
2598
2599     target_len = target_str.Length + sizeof(targetW);
2600     target = malloc( target_len );
2601     memcpy( target, target_str.Buffer, target_str.Length );
2602     memcpy( target + target_str.Length/sizeof(WCHAR), targetW, sizeof(targetW) );
2603
2604     err = RegCreateKeyExA( hkey_main, "link", 0, NULL, REG_OPTION_CREATE_LINK,
2605                            KEY_ALL_ACCESS, NULL, &link, NULL );
2606     ok( err == ERROR_SUCCESS, "RegCreateKeyEx failed: %lu\n", err );
2607
2608     /* REG_SZ is not allowed */
2609     err = RegSetValueExA( link, "SymbolicLinkValue", 0, REG_SZ, (BYTE *)"foobar", sizeof("foobar") );
2610     ok( err == ERROR_ACCESS_DENIED, "RegSetValueEx wrong error %lu\n", err );
2611     err = RegSetValueExA( link, "SymbolicLinkValue", 0, REG_LINK,
2612                           (BYTE *)target, target_len - sizeof(WCHAR) );
2613     ok( err == ERROR_SUCCESS, "RegSetValueEx failed error %lu\n", err );
2614     /* other values are not allowed */
2615     err = RegSetValueExA( link, "link", 0, REG_LINK, (BYTE *)target, target_len - sizeof(WCHAR) );
2616     ok( err == ERROR_ACCESS_DENIED, "RegSetValueEx wrong error %lu\n", err );
2617
2618     /* try opening the target through the link */
2619
2620     err = RegOpenKeyA( hkey_main, "link", &key );
2621     ok( err == ERROR_FILE_NOT_FOUND, "RegOpenKey wrong error %lu\n", err );
2622
2623     err = RegCreateKeyExA( hkey_main, "target", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );
2624     ok( err == ERROR_SUCCESS, "RegCreateKeyEx failed error %lu\n", err );
2625
2626     dw = 0xbeef;
2627     err = RegSetValueExA( key, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
2628     ok( err == ERROR_SUCCESS, "RegSetValueEx failed error %lu\n", err );
2629     RegCloseKey( key );
2630
2631     err = RegOpenKeyA( hkey_main, "link", &key );
2632     ok( err == ERROR_SUCCESS, "RegOpenKey failed error %lu\n", err );
2633
2634     len = sizeof(buffer);
2635     err = RegQueryValueExA( key, "value", NULL, &type, buffer, &len );
2636     ok( err == ERROR_SUCCESS, "RegOpenKey failed error %lu\n", err );
2637     ok( len == sizeof(DWORD), "wrong len %lu\n", len );
2638
2639     len = sizeof(buffer);
2640     err = RegQueryValueExA( key, "SymbolicLinkValue", NULL, &type, buffer, &len );
2641     ok( err == ERROR_FILE_NOT_FOUND, "RegQueryValueEx wrong error %lu\n", err );
2642
2643     /* REG_LINK can be created in non-link keys */
2644     err = RegSetValueExA( key, "SymbolicLinkValue", 0, REG_LINK,
2645                           (BYTE *)target, target_len - sizeof(WCHAR) );
2646     ok( err == ERROR_SUCCESS, "RegSetValueEx failed error %lu\n", err );
2647     len = sizeof(buffer);
2648     err = RegQueryValueExA( key, "SymbolicLinkValue", NULL, &type, buffer, &len );
2649     ok( err == ERROR_SUCCESS, "RegQueryValueEx failed error %lu\n", err );
2650     ok( len == target_len - sizeof(WCHAR), "wrong len %lu\n", len );
2651     err = RegDeleteValueA( key, "SymbolicLinkValue" );
2652     ok( err == ERROR_SUCCESS, "RegDeleteValue failed error %lu\n", err );
2653
2654     RegCloseKey( key );
2655
2656     err = RegCreateKeyExA( hkey_main, "link", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );
2657     ok( err == ERROR_SUCCESS, "RegCreateKeyEx failed error %lu\n", err );
2658
2659     len = sizeof(buffer);
2660     err = RegQueryValueExA( key, "value", NULL, &type, buffer, &len );
2661     ok( err == ERROR_SUCCESS, "RegQueryValueEx failed error %lu\n", err );
2662     ok( len == sizeof(DWORD), "wrong len %lu\n", len );
2663
2664     err = RegQueryValueExA( key, "SymbolicLinkValue", NULL, &type, buffer, &len );
2665     ok( err == ERROR_FILE_NOT_FOUND, "RegQueryValueEx wrong error %lu\n", err );
2666     RegCloseKey( key );
2667
2668     /* now open the symlink itself */
2669
2670     err = RegOpenKeyExA( hkey_main, "link", REG_OPTION_OPEN_LINK, KEY_ALL_ACCESS, &key );
2671     ok( err == ERROR_SUCCESS, "RegOpenKeyEx failed error %lu\n", err );
2672     len = sizeof(buffer);
2673     err = RegQueryValueExA( key, "SymbolicLinkValue", NULL, &type, buffer, &len );
2674     ok( err == ERROR_SUCCESS, "RegQueryValueEx failed error %lu\n", err );
2675     ok( len == target_len - sizeof(WCHAR), "wrong len %lu\n", len );
2676     RegCloseKey( key );
2677
2678     err = RegCreateKeyExA( hkey_main, "link", 0, NULL, REG_OPTION_OPEN_LINK,
2679                            KEY_ALL_ACCESS, NULL, &key, NULL );
2680     ok( err == ERROR_SUCCESS, "RegCreateKeyEx failed error %lu\n", err );
2681     len = sizeof(buffer);
2682     err = RegQueryValueExA( key, "SymbolicLinkValue", NULL, &type, buffer, &len );
2683     ok( err == ERROR_SUCCESS, "RegQueryValueEx failed error %lu\n", err );
2684     ok( len == target_len - sizeof(WCHAR), "wrong len %lu\n", len );
2685     RegCloseKey( key );
2686
2687     err = RegCreateKeyExA( hkey_main, "link", 0, NULL, REG_OPTION_CREATE_LINK,
2688                            KEY_ALL_ACCESS, NULL, &key, NULL );
2689     ok( err == ERROR_ALREADY_EXISTS, "RegCreateKeyEx wrong error %lu\n", err );
2690
2691     err = RegCreateKeyExA( hkey_main, "link", 0, NULL, REG_OPTION_CREATE_LINK | REG_OPTION_OPEN_LINK,
2692                            KEY_ALL_ACCESS, NULL, &key, NULL );
2693     ok( err == ERROR_ALREADY_EXISTS, "RegCreateKeyEx wrong error %lu\n", err );
2694
2695     err = RegDeleteKeyA( hkey_main, "target" );
2696     ok( err == ERROR_SUCCESS, "RegDeleteKey failed error %lu\n", err );
2697
2698     err = RegDeleteKeyA( hkey_main, "link" );
2699     ok( err == ERROR_FILE_NOT_FOUND, "RegDeleteKey wrong error %lu\n", err );
2700
2701     status = pNtDeleteKey( link );
2702     ok( !status, "NtDeleteKey failed: 0x%08lx\n", status );
2703     RegCloseKey( link );
2704
2705     free( target );
2706     pRtlFreeUnicodeString( &target_str );
2707 }
2708
2709 static DWORD get_key_value( HKEY root, const char *name, DWORD flags )
2710 {
2711     HKEY key;
2712     DWORD err, type, dw = 1, len = sizeof(dw);
2713
2714     err = RegOpenKeyExA( root, name, 0, flags | KEY_ALL_ACCESS, &key );
2715     if (err == ERROR_FILE_NOT_FOUND) return 0;
2716     ok( err == ERROR_SUCCESS, "%08lx: RegOpenKeyEx failed: %lu\n", flags, err );
2717
2718     err = RegQueryValueExA( key, "value", NULL, &type, (BYTE *)&dw, &len );
2719     if (err == ERROR_FILE_NOT_FOUND)
2720         dw = 0;
2721     else
2722         ok( err == ERROR_SUCCESS, "%08lx: RegQueryValueEx failed: %lu\n", flags, err );
2723     RegCloseKey( key );
2724     return dw;
2725 }
2726
2727 static void _check_key_value( int line, HANDLE root, const char *name, DWORD flags, DWORD expect )
2728 {
2729     DWORD dw = get_key_value( root, name, flags );
2730     ok_(__FILE__,line)( dw == expect, "%08lx: wrong value %lu/%lu\n", flags, dw, expect );
2731 }
2732 #define check_key_value(root,name,flags,expect) _check_key_value( __LINE__, root, name, flags, expect )
2733
2734 static void _check_enum_value( int line, const char *name, DWORD flags, DWORD subkeys_in, BOOL found_in)
2735 {
2736     char buffer[1024];
2737     DWORD err, i, subkeys;
2738     BOOL found;
2739     HKEY key;
2740
2741     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, name, 0, flags, &key );
2742     ok_( __FILE__, line )( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
2743
2744     err = RegQueryInfoKeyA( key, NULL, NULL, NULL, &subkeys,
2745                             NULL, NULL, NULL, NULL, NULL, NULL, NULL );
2746     ok_( __FILE__, line )( err == ERROR_SUCCESS, "RegQueryInfoKeyA failed: %lu\n", err );
2747     ok_( __FILE__, line )( subkeys == subkeys_in, "wrong number of subkeys: %lu\n", subkeys );
2748
2749     found = FALSE;
2750     for (i = 0; i < subkeys; i++)
2751     {
2752         err = RegEnumKeyA( key, i, buffer, sizeof(buffer) );
2753         ok_( __FILE__, line )( err == ERROR_SUCCESS, "RegEnumKeyA failed: %lu\n", err );
2754
2755         if (!strcmp(buffer, "Wine"))
2756             found = TRUE;
2757     }
2758     ok_( __FILE__, line )( found == found_in, "found equals %d\n", found );
2759     RegCloseKey( key );
2760 }
2761 #define check_enum_value(name, flags, subkeys, found) _check_enum_value( __LINE__, name, flags, subkeys, found )
2762
2763 static void test_redirection(void)
2764 {
2765     DWORD err, type, dw, len;
2766     HKEY key, key32, key64, root, root32, root64;
2767     DWORD subkeys, subkeys32, subkeys64;
2768
2769     if (!has_wow64())
2770     {
2771         skip( "Not on Wow64, no redirection\n" );
2772         return;
2773     }
2774
2775     if (limited_user)
2776     {
2777         skip("not enough privileges to modify HKLM\n");
2778         return;
2779     }
2780
2781     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
2782                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &root64, NULL );
2783     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2784
2785     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
2786                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &root32, NULL );
2787     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2788
2789     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Winetest", 0, NULL, 0,
2790                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key64, NULL );
2791     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2792
2793     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Winetest", 0, NULL, 0,
2794                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key32, NULL );
2795     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2796
2797     dw = 64;
2798     err = RegSetValueExA( key64, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
2799     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
2800
2801     dw = 32;
2802     err = RegSetValueExA( key32, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
2803     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
2804
2805     dw = 0;
2806     len = sizeof(dw);
2807     err = RegQueryValueExA( key32, "value", NULL, &type, (BYTE *)&dw, &len );
2808     ok( err == ERROR_SUCCESS, "RegQueryValueExA failed: %lu\n", err );
2809     ok( dw == 32, "wrong value %lu\n", dw );
2810
2811     dw = 0;
2812     len = sizeof(dw);
2813     err = RegQueryValueExA( key64, "value", NULL, &type, (BYTE *)&dw, &len );
2814     ok( err == ERROR_SUCCESS, "RegQueryValueExA failed: %lu\n", err );
2815     ok( dw == 64, "wrong value %lu\n", dw );
2816
2817     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software", 0, NULL, 0,
2818                            KEY_ALL_ACCESS, NULL, &key, NULL );
2819     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2820     check_key_value( key, "Wine\\Winetest", 0, ptr_size );
2821     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, ptr_size );
2822     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2823     check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, ptr_size == 32 ? 0 : 32 );
2824     check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, ptr_size == 32 ? 0 : 32 );
2825     check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, ptr_size == 32 ? 0 : 32 );
2826     RegCloseKey( key );
2827
2828     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software", 0, NULL, 0,
2829                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2830     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2831     dw = get_key_value( key, "Wine\\Winetest", 0 );
2832     ok( dw == 64 || broken(dw == 32) /* win7 */, "wrong value %lu\n", dw );
2833     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 64 );
2834     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2835     check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, 32 );
2836     check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, 32 );
2837     check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2838     RegCloseKey( key );
2839
2840     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software", 0, NULL, 0,
2841                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2842     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2843     check_key_value( key, "Wine\\Winetest", 0, 32 );
2844     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 32 );
2845     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2846     check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, 0 );
2847     check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, 0 );
2848     check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 0 );
2849     RegCloseKey( key );
2850
2851     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Wine\\Winetest", 0, ptr_size );
2852     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Wine\\Winetest", 0, 32 );
2853     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Wine\\Winetest", KEY_WOW64_64KEY, 64 );
2854     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2855     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, 32 );
2856     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2857
2858     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node", 0, NULL, 0,
2859                            KEY_ALL_ACCESS, NULL, &key, NULL );
2860     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2861     check_key_value( key, "Wine\\Winetest", 0, 32 );
2862     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 32 );
2863     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2864     RegCloseKey( key );
2865
2866     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node", 0, NULL, 0,
2867                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2868     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2869     check_key_value( key, "Wine\\Winetest", 0, 32 );
2870     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 32 );
2871     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2872     RegCloseKey( key );
2873
2874     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node", 0, NULL, 0,
2875                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2876     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2877     check_key_value( key, "Wine\\Winetest", 0, 32 );
2878     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 32 );
2879     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
2880     RegCloseKey( key );
2881
2882     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Wine", 0, NULL, 0,
2883                            KEY_ALL_ACCESS, NULL, &key, NULL );
2884     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2885     check_key_value( key, "Winetest", 0, 32 );
2886     check_key_value( key, "Winetest", KEY_WOW64_64KEY, 32 );
2887     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
2888     RegCloseKey( key );
2889
2890     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Wine", 0, NULL, 0,
2891                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2892     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2893     check_key_value( key, "Winetest", 0, 32 );
2894     check_key_value( key, "Winetest", KEY_WOW64_64KEY, 32 );
2895     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
2896     RegCloseKey( key );
2897
2898     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Wine", 0, NULL, 0,
2899                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2900     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2901     check_key_value( key, "Winetest", 0, 32 );
2902     check_key_value( key, "Winetest", KEY_WOW64_64KEY, 32 );
2903     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
2904     RegCloseKey( key );
2905
2906     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
2907                            KEY_ALL_ACCESS, NULL, &key, NULL );
2908     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2909     check_key_value( key, "Winetest", 0, ptr_size );
2910     check_key_value( key, "Winetest", KEY_WOW64_64KEY, ptr_size );
2911     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
2912     RegCloseKey( key );
2913
2914     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
2915                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2916     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2917     check_key_value( key, "Winetest", 0, 64 );
2918     check_key_value( key, "Winetest", KEY_WOW64_64KEY, 64 );
2919     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
2920     RegCloseKey( key );
2921
2922     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine", 0, NULL, 0,
2923                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key, NULL );
2924     ok( err == ERROR_SUCCESS, "RegCreateKeyExA failed: %lu\n", err );
2925     check_key_value( key, "Winetest", 0, 32 );
2926     check_key_value( key, "Winetest", KEY_WOW64_64KEY, 32 );
2927     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
2928     RegCloseKey( key );
2929
2930     if (pRegDeleteKeyExA)
2931     {
2932         err = pRegDeleteKeyExA( key32, "", KEY_WOW64_32KEY, 0 );
2933         ok( err == ERROR_SUCCESS, "RegDeleteKey failed: %lu\n", err );
2934         err = pRegDeleteKeyExA( key64, "", KEY_WOW64_64KEY, 0 );
2935         ok( err == ERROR_SUCCESS, "RegDeleteKey failed: %lu\n", err );
2936         pRegDeleteKeyExA( key64, "", KEY_WOW64_64KEY, 0 );
2937         pRegDeleteKeyExA( root64, "", KEY_WOW64_64KEY, 0 );
2938     }
2939     else
2940     {
2941         err = RegDeleteKeyA( key32, "" );
2942         ok( err == ERROR_SUCCESS, "RegDeleteKey failed: %lu\n", err );
2943         err = RegDeleteKeyA( key64, "" );
2944         ok( err == ERROR_SUCCESS, "RegDeleteKey failed: %lu\n", err );
2945         RegDeleteKeyA( key64, "" );
2946         RegDeleteKeyA( root64, "" );
2947     }
2948     RegCloseKey( key32 );
2949     RegCloseKey( key64 );
2950     RegCloseKey( root32 );
2951     RegCloseKey( root64 );
2952
2953     err = RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\WOW6432Node\\test1\\test2", 0, NULL, 0,
2954                               KEY_WRITE | KEY_WOW64_32KEY, NULL, &key, NULL );
2955     ok(!err, "got %#lx.\n", err);
2956     RegCloseKey(key);
2957
2958     err = RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\test1\\test2", 0, NULL, 0, KEY_WRITE | KEY_WOW64_32KEY,
2959                               NULL, &key, NULL );
2960     ok(!err, "got %#lx.\n", err);
2961     RegCloseKey(key);
2962
2963     err = RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"Software\\test1\\test2", 0, KEY_WRITE | KEY_WOW64_32KEY, &key );
2964     ok(!err, "got %#lx.\n", err);
2965     RegCloseKey(key);
2966
2967     if (pRegDeleteTreeA)
2968     {
2969         err = pRegDeleteTreeA(HKEY_LOCAL_MACHINE, "Software\\WOW6432Node\\test1");
2970         ok(!err, "got %#lx.\n", err);
2971         err = pRegDeleteTreeA(HKEY_LOCAL_MACHINE, "Software\\test1");
2972         ok(err == ERROR_FILE_NOT_FOUND, "got %#lx.\n", err);
2973     }
2974
2975     /* Software\Classes is shared/reflected so behavior is different */
2976
2977     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine",
2978                            0, NULL, 0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key64, NULL);
2979     if (err == ERROR_ACCESS_DENIED)
2980     {
2981         skip("Not authorized to modify the Classes key\n");
2982         return;
2983     }
2984     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
2985
2986     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
2987                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key );
2988     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
2989     RegCloseKey( key );
2990
2991     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
2992                          0, KEY_ALL_ACCESS, &key );
2993     ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
2994         "RegOpenKeyExA failed: %lu\n", err );
2995     if (!err) RegCloseKey( key );
2996
2997     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
2998                            0, NULL, 0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key32, NULL);
2999     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3000
3001     dw = 32;
3002     err = RegSetValueExA( key32, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3003     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3004
3005     dw = 64;
3006     err = RegSetValueExA( key64, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3007     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3008
3009     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine", 0, 64 );
3010     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine", KEY_WOW64_64KEY, 64 );
3011     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine", KEY_WOW64_32KEY, 64 );
3012     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine", 0, ptr_size == 64 ? 0 : 64 );
3013     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine", KEY_WOW64_64KEY, 0 );
3014     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine", KEY_WOW64_32KEY, 64 );
3015
3016     RegDeleteKeyA( key32, "" );
3017     RegCloseKey( key32 );
3018
3019     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine", 0, 0 );
3020     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine", KEY_WOW64_64KEY, 0 );
3021     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine", KEY_WOW64_32KEY, 0 );
3022     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine", 0, 0 );
3023     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine", KEY_WOW64_64KEY, 0 );
3024     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine", KEY_WOW64_32KEY, 0 );
3025
3026     RegDeleteKeyA( key64, "" );
3027     RegCloseKey( key64 );
3028
3029     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes", 0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &root64 );
3030     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3031
3032     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes", 0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &root32 );
3033     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3034
3035     err = RegCreateKeyExA( root64, "Wine", 0, NULL, 0,
3036                            KEY_ALL_ACCESS, NULL, &key64, NULL);
3037     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3038
3039     err = RegCreateKeyExA( key64, "Wine", 0, NULL, 0,
3040                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key, NULL);
3041     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3042     RegDeleteKeyA( key, "" );
3043     RegCloseKey( key );
3044
3045     err = RegOpenKeyExA( root32, "Wine", 0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key );
3046     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3047     RegCloseKey( key );
3048
3049     err = RegOpenKeyExA( root32, "Wine", 0, KEY_ALL_ACCESS, &key );
3050     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3051     RegCloseKey( key );
3052
3053     err = RegCreateKeyExA( root32, "Wine", 0, NULL, 0,
3054                            KEY_ALL_ACCESS, NULL, &key32, NULL);
3055     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3056
3057     dw = 32;
3058     err = RegSetValueExA( key32, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3059     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3060
3061     dw = 64;
3062     err = RegSetValueExA( key64, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3063     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3064
3065     check_key_value( root64, "Wine", 0, 64 );
3066     check_key_value( root64, "Wine", KEY_WOW64_64KEY, 64 );
3067     check_key_value( root64, "Wine", KEY_WOW64_32KEY, 64 );
3068     check_key_value( root32, "Wine", 0, 64 );
3069     check_key_value( root32, "Wine", KEY_WOW64_64KEY, 64 );
3070     check_key_value( root32, "Wine", KEY_WOW64_32KEY, 64 );
3071
3072     RegDeleteKeyA( key32, "" );
3073     RegCloseKey( key32 );
3074
3075     check_key_value( root64, "Wine", 0, 0 );
3076     check_key_value( root64, "Wine", KEY_WOW64_64KEY, 0 );
3077     check_key_value( root64, "Wine", KEY_WOW64_32KEY, 0 );
3078     check_key_value( root32, "Wine", 0, 0 );
3079     check_key_value( root32, "Wine", KEY_WOW64_64KEY, 0 );
3080     check_key_value( root32, "Wine", KEY_WOW64_32KEY, 0 );
3081
3082     RegDeleteKeyA( key64, "" );
3083     RegCloseKey( key64 );
3084
3085     err = RegCreateKeyExA( root32, "Wine", 0, NULL, 0,
3086                            KEY_ALL_ACCESS, NULL, &key32, NULL);
3087     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3088
3089     dw = 32;
3090     err = RegSetValueExA( key32, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3091     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3092
3093     check_key_value( root64, "Wine", 0, 32 );
3094     check_key_value( root64, "Wine", KEY_WOW64_64KEY, 32 );
3095     check_key_value( root64, "Wine", KEY_WOW64_32KEY, 32 );
3096     check_key_value( root32, "Wine", 0, 32 );
3097     check_key_value( root32, "Wine", KEY_WOW64_64KEY, 32 );
3098     check_key_value( root32, "Wine", KEY_WOW64_32KEY, 32 );
3099
3100     RegDeleteKeyA( key32, "" );
3101     RegCloseKey( key32 );
3102
3103     RegCloseKey( root64 );
3104     RegCloseKey( root32 );
3105
3106     err = RegOpenKeyExA( HKEY_CLASSES_ROOT, "Interface",
3107                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &root64 );
3108     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3109
3110     err = RegOpenKeyExA( HKEY_CLASSES_ROOT, "Interface",
3111                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &root32 );
3112     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3113
3114     err = RegOpenKeyExA( HKEY_CLASSES_ROOT, "Interface",
3115                          0, KEY_ALL_ACCESS, &root );
3116     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3117
3118     err = RegCreateKeyExA( root32, "Wine", 0, NULL, 0,
3119                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key32, NULL);
3120     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3121
3122     err = RegOpenKeyExA( root, "Wine", 0, KEY_ALL_ACCESS, &key );
3123     ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3124         "RegOpenKeyExA failed: %lu\n", err );
3125     if (!err) RegCloseKey( key );
3126
3127     RegDeleteKeyA( key32, "" );
3128     RegCloseKey( key32 );
3129
3130     err = RegCreateKeyExA( root64, "Wine", 0, NULL, 0,
3131                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key64, NULL);
3132     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3133
3134     err = RegOpenKeyExA( root, "Wine", 0, KEY_ALL_ACCESS, &key );
3135     ok( err == (ptr_size == 32 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3136         "RegOpenKeyExA failed: %lu\n", err );
3137     if (!err) RegCloseKey( key );
3138
3139     RegDeleteKeyA( key64, "" );
3140     RegCloseKey( key64 );
3141
3142     RegDeleteKeyA( root64, "" );
3143     RegDeleteKeyA( root32, "" );
3144     RegDeleteKeyA( root, "" );
3145
3146     RegCloseKey( root64 );
3147     RegCloseKey( root32 );
3148     RegCloseKey( root );
3149
3150     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes",
3151                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &root64 );
3152     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3153
3154     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes",
3155                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &root32 );
3156     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3157
3158     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes",
3159                          0, KEY_ALL_ACCESS, &root );
3160     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3161
3162     err = RegOpenKeyExA( root64, "Interface",
3163                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &key64 );
3164     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3165
3166     err = RegOpenKeyExA( root32, "Interface",
3167                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key32 );
3168     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3169
3170     err = RegOpenKeyExA( root, "Interface",
3171                          0, KEY_ALL_ACCESS, &key );
3172     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3173
3174     RegCloseKey( root64 );
3175     RegCloseKey( root32 );
3176     RegCloseKey( root );
3177
3178     root64 = key64;
3179     root32 = key32;
3180     root = key;
3181
3182     err = RegCreateKeyExA( root32, "Wine", 0, NULL, 0,
3183                            KEY_WOW64_32KEY | KEY_ALL_ACCESS, NULL, &key32, NULL);
3184     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3185
3186     err = RegOpenKeyExA( root, "Wine", 0, KEY_ALL_ACCESS, &key );
3187     ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3188         "RegOpenKeyExA failed: %lu\n", err );
3189     if (!err) RegCloseKey( key );
3190
3191     RegDeleteKeyA( key32, "" );
3192     RegCloseKey( key32 );
3193
3194     err = RegCreateKeyExA( root64, "Wine", 0, NULL, 0,
3195                            KEY_WOW64_64KEY | KEY_ALL_ACCESS, NULL, &key64, NULL);
3196     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3197
3198     err = RegOpenKeyExA( root, "Wine", 0, KEY_ALL_ACCESS, &key );
3199     ok( err == (ptr_size == 32 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3200         "RegOpenKeyExA failed: %lu\n", err );
3201     if (!err) RegCloseKey( key );
3202
3203     RegDeleteKeyA( key64, "" );
3204     RegCloseKey( key64 );
3205
3206     RegDeleteKeyA( root, "" );
3207     RegCloseKey( root );
3208
3209     err = RegCreateKeyExA( root64, "Wine", 0, NULL, 0,
3210                            KEY_ALL_ACCESS, NULL, &key64, NULL);
3211     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3212
3213     err = RegOpenKeyExA( root32, "Wine", 0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key );
3214     ok( err == ERROR_FILE_NOT_FOUND, "RegOpenKeyExA failed: %lu\n", err );
3215
3216     err = RegOpenKeyExA( root32, "Wine", 0, KEY_ALL_ACCESS, &key );
3217     ok( err == ERROR_FILE_NOT_FOUND, "RegOpenKeyExA failed: %lu\n", err );
3218
3219     err = RegCreateKeyExA( root32, "Wine", 0, NULL, 0,
3220                            KEY_ALL_ACCESS, NULL, &key32, NULL);
3221     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3222
3223     dw = 32;
3224     err = RegSetValueExA( key32, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3225     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3226
3227     dw = 64;
3228     err = RegSetValueExA( key64, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3229     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3230
3231     check_key_value( root64, "Wine", 0, 64 );
3232     check_key_value( root64, "Wine", KEY_WOW64_64KEY, 64 );
3233     check_key_value( root64, "Wine", KEY_WOW64_32KEY, 32 );
3234     check_key_value( root32, "Wine", 0, 32 );
3235     check_key_value( root32, "Wine", KEY_WOW64_64KEY, 32 );
3236     check_key_value( root32, "Wine", KEY_WOW64_32KEY, 32 );
3237
3238     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface",
3239                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &key );
3240     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3241     check_key_value( key, "Wine", 0, 64 );
3242     check_key_value( key, "Wine", KEY_WOW64_64KEY, 64 );
3243     check_key_value( key, "Wine", KEY_WOW64_32KEY, 32 );
3244     RegCloseKey( key );
3245
3246     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface",
3247                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key );
3248     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3249     check_key_value( key, "Wine", 0, 32 );
3250     check_key_value( key, "Wine", KEY_WOW64_64KEY, 32 );
3251     check_key_value( key, "Wine", KEY_WOW64_32KEY, 32 );
3252     RegCloseKey( key );
3253
3254     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface\\Wine", 0, ptr_size );
3255     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface\\Wine", KEY_WOW64_64KEY, 64 );
3256     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface\\Wine", KEY_WOW64_32KEY, 32 );
3257
3258     RegDeleteKeyA( key32, "" );
3259     RegCloseKey( key32 );
3260
3261     check_key_value( root64, "Wine", 0, 64 );
3262     check_key_value( root64, "Wine", KEY_WOW64_64KEY, 64 );
3263     check_key_value( root64, "Wine", KEY_WOW64_32KEY, 0 );
3264     check_key_value( root32, "Wine", 0, 0 );
3265     check_key_value( root32, "Wine", KEY_WOW64_64KEY, 0 );
3266     check_key_value( root32, "Wine", KEY_WOW64_32KEY, 0 );
3267
3268     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface\\Wine", 0, ptr_size == 64 ? 64 : 0 );
3269     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface\\Wine", KEY_WOW64_64KEY, 64 );
3270     check_key_value( HKEY_LOCAL_MACHINE, "Software\\Classes\\Interface\\Wine", KEY_WOW64_32KEY, 0 );
3271
3272     RegDeleteKeyA( key64, "" );
3273     RegCloseKey( key64 );
3274
3275     err = RegCreateKeyExA( root32, "Wine", 0, NULL, 0,
3276                            KEY_ALL_ACCESS, NULL, &key32, NULL);
3277     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3278
3279     dw = 32;
3280     err = RegSetValueExA( key32, "value", 0, REG_DWORD, (BYTE *)&dw, sizeof(dw) );
3281     ok( err == ERROR_SUCCESS, "RegSetValueExA failed: %lu\n", err );
3282
3283     check_key_value( root64, "Wine", 0, 0 );
3284     check_key_value( root64, "Wine", KEY_WOW64_64KEY, 0 );
3285     check_key_value( root64, "Wine", KEY_WOW64_32KEY, 32 );
3286     check_key_value( root32, "Wine", 0, 32 );
3287     check_key_value( root32, "Wine", KEY_WOW64_64KEY, 32 );
3288     check_key_value( root32, "Wine", KEY_WOW64_32KEY, 32 );
3289
3290     RegDeleteKeyA( key32, "" );
3291     RegCloseKey( key32 );
3292
3293     RegCloseKey( root64 );
3294     RegCloseKey( root32 );
3295
3296     err = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
3297                            0, NULL, 0, KEY_ALL_ACCESS, NULL, &key32, NULL);
3298     ok( err == ERROR_SUCCESS, "RegCreateKeyA failed: %lu\n", err );
3299
3300     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
3301                          0, KEY_ALL_ACCESS, &key );
3302     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3303     RegCloseKey( key );
3304
3305     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
3306                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key );
3307     todo_wine_if(ptr_size == 64) ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3308         "RegOpenKeyExA failed: %lu\n", err );
3309     if (!err) RegCloseKey( key );
3310
3311     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node\\Wine",
3312                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &key );
3313     ok( err == (ptr_size == 32 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3314         "RegOpenKeyExA failed: %lu\n", err );
3315     if (!err) RegCloseKey( key );
3316
3317     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine",
3318                          0, KEY_ALL_ACCESS, &key );
3319     ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3320         "RegOpenKeyExA failed: %lu\n", err );
3321     if (!err) RegCloseKey( key );
3322
3323     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine",
3324                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &key );
3325     todo_wine_if(ptr_size == 64) ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3326         "RegOpenKeyExA failed: %lu\n", err );
3327     if (!err) RegCloseKey( key );
3328
3329     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wine",
3330                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &key );
3331     ok( err == (ptr_size == 64 ? ERROR_FILE_NOT_FOUND : ERROR_SUCCESS),
3332         "RegOpenKeyExA failed: %lu\n", err );
3333     if (!err) RegCloseKey( key );
3334
3335     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\Wow6432Node",
3336                          0, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &root32 );
3337     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3338
3339     err = RegQueryInfoKeyA(root32, NULL, NULL, NULL, &subkeys,
3340                            NULL, NULL, NULL, NULL, NULL, NULL, NULL );
3341     ok( err == ERROR_SUCCESS, "RegQueryInfoKeyA failed: %lu\n", err );
3342     ok( subkeys > 0, "wrong number of subkeys: %lu\n", subkeys );
3343     subkeys32 = subkeys;
3344     RegCloseKey( root32 );
3345
3346     err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes",
3347                          0, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &root64 );
3348     ok( err == ERROR_SUCCESS, "RegOpenKeyExA failed: %lu\n", err );
3349
3350     err = RegQueryInfoKeyA(root64, NULL, NULL, NULL, &subkeys,
3351                            NULL, NULL, NULL, NULL, NULL, NULL, NULL );
3352     ok( err == ERROR_SUCCESS, "RegQueryInfoKeyA failed: %lu\n", err );
3353     ok( subkeys > subkeys32, "wrong number of subkeys: %lu\n", subkeys );
3354     subkeys64 = subkeys;
3355     RegCloseKey( root64 );
3356
3357     check_enum_value( "Software\\Classes",
3358                       KEY_WOW64_32KEY | KEY_ALL_ACCESS, subkeys64, ptr_size == 32 );
3359     check_enum_value( "Software\\Classes",
3360                       KEY_WOW64_64KEY | KEY_ALL_ACCESS, subkeys64, ptr_size == 32 );
3361     check_enum_value( "Software\\Classes",
3362                       KEY_ALL_ACCESS, subkeys64, ptr_size == 32 );
3363     check_enum_value( "Software\\Classes\\Wow6432Node",
3364                       KEY_WOW64_32KEY | KEY_ALL_ACCESS, subkeys32, ptr_size == 64 );
3365     check_enum_value( "Software\\Classes\\Wow6432Node",
3366                       KEY_WOW64_64KEY | KEY_ALL_ACCESS, subkeys32, ptr_size == 64 );
3367     check_enum_value( "Software\\Classes\\Wow6432Node",
3368                       KEY_ALL_ACCESS, subkeys32, ptr_size == 64 );
3369     check_enum_value( "Software\\Wow6432Node\\Classes",
3370                       KEY_WOW64_32KEY | KEY_ALL_ACCESS, subkeys64, ptr_size == 32 );
3371     check_enum_value( "Software\\Wow6432Node\\Classes",
3372                       KEY_WOW64_64KEY | KEY_ALL_ACCESS, subkeys32, ptr_size == 64 );
3373     check_enum_value( "Software\\Wow6432Node\\Classes",
3374                       KEY_ALL_ACCESS, ptr_size == 32 ? subkeys64 : subkeys32, TRUE );
3375
3376     RegDeleteKeyA( key32, "" );
3377     RegCloseKey( key32 );
3378 }
3379
3380 static void test_classesroot(void)
3381 {
3382     HKEY hkey, hklm, hkcr, hkeysub1, hklmsub1, hkcrsub1, hklmsub2, hkcrsub2;
3383     DWORD size = 8;
3384     DWORD type = REG_SZ;
3385     static CHAR buffer[8];
3386     LONG res;
3387
3388     /* create a key in the user's classes */
3389     if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Classes\\WineTestCls", &hkey ))
3390     {
3391         delete_key( hkey );
3392         RegCloseKey( hkey );
3393     }
3394     res = RegCreateKeyExA( HKEY_CURRENT_USER, "Software\\Classes\\WineTestCls", 0, NULL, 0,
3395                            KEY_QUERY_VALUE|KEY_SET_VALUE, NULL, &hkey, NULL );
3396     if (res == ERROR_ACCESS_DENIED)
3397     {
3398         skip("not enough privileges to add a user class\n");
3399         return;
3400     }
3401     ok(!IS_HKCR(hkey), "hkcr mask set in %p\n", hkey);
3402
3403     /* try to open that key in hkcr */
3404     res = RegOpenKeyExA( HKEY_CLASSES_ROOT, "WineTestCls", 0,
3405                          KEY_QUERY_VALUE|KEY_SET_VALUE, &hkcr );
3406     todo_wine ok(res == ERROR_SUCCESS ||
3407                  broken(res == ERROR_FILE_NOT_FOUND /* WinNT */),
3408                  "test key not found in hkcr: %ld\n", res);
3409     if (res)
3410     {
3411         skip("HKCR key merging not supported\n");
3412         delete_key( hkey );
3413         RegCloseKey( hkey );
3414         return;
3415     }
3416
3417     todo_wine ok(IS_HKCR(hkcr), "hkcr mask not set in %p\n", hkcr);
3418
3419     /* set a value in user's classes */
3420     res = RegSetValueExA(hkey, "val1", 0, REG_SZ, (const BYTE *)"user", sizeof("user"));
3421     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3422
3423     /* try to find the value in hkcr */
3424     res = RegQueryValueExA(hkcr, "val1", NULL, &type, (LPBYTE)buffer, &size);
3425     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3426     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3427
3428     /* modify the value in hkcr */
3429     res = RegSetValueExA(hkcr, "val1", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3430     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3431
3432     /* check if the value is also modified in user's classes */
3433     res = RegQueryValueExA(hkey, "val1", NULL, &type, (LPBYTE)buffer, &size);
3434     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3435     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3436
3437     /* set a value in hkcr */
3438     res = RegSetValueExA(hkcr, "val0", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3439     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3440
3441     /* try to find the value in user's classes */
3442     res = RegQueryValueExA(hkey, "val0", NULL, &type, (LPBYTE)buffer, &size);
3443     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3444     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3445
3446     /* modify the value in user's classes */
3447     res = RegSetValueExA(hkey, "val0", 0, REG_SZ, (const BYTE *)"user", sizeof("user"));
3448     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3449
3450     /* check if the value is also modified in hkcr */
3451     res = RegQueryValueExA(hkcr, "val0", NULL, &type, (LPBYTE)buffer, &size);
3452     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3453     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3454
3455     /* cleanup */
3456     delete_key( hkey );
3457     delete_key( hkcr );
3458     RegCloseKey( hkey );
3459     RegCloseKey( hkcr );
3460
3461     /* create a key in the hklm classes */
3462     if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Classes\\WineTestCls", &hklm ))
3463     {
3464         delete_key( hklm );
3465         RegCloseKey( hklm );
3466     }
3467     res = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\WineTestCls", 0, NULL, REG_OPTION_NON_VOLATILE,
3468                            KEY_ALL_ACCESS, NULL, &hklm, NULL );
3469     if (res == ERROR_ACCESS_DENIED)
3470     {
3471         skip("not enough privileges to add a system class\n");
3472         return;
3473     }
3474     ok(!IS_HKCR(hklm), "hkcr mask set in %p\n", hklm);
3475
3476     /* try to open that key in hkcr */
3477     res = RegOpenKeyExA( HKEY_CLASSES_ROOT, "WineTestCls", 0,
3478                          KEY_QUERY_VALUE|KEY_SET_VALUE, &hkcr );
3479     ok(res == ERROR_SUCCESS,
3480        "test key not found in hkcr: %ld\n", res);
3481     ok(IS_HKCR(hkcr), "hkcr mask not set in %p\n", hkcr);
3482     if (res)
3483     {
3484         delete_key( hklm );
3485         RegCloseKey( hklm );
3486         return;
3487     }
3488
3489     /* set a value in hklm classes */
3490     res = RegSetValueExA(hklm, "val2", 0, REG_SZ, (const BYTE *)"hklm", sizeof("hklm"));
3491     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3492
3493     /* try to find the value in hkcr */
3494     res = RegQueryValueExA(hkcr, "val2", NULL, &type, (LPBYTE)buffer, &size);
3495     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3496     ok(!strcmp( buffer, "hklm" ), "value set to '%s'\n", buffer );
3497
3498     /* modify the value in hkcr */
3499     res = RegSetValueExA(hkcr, "val2", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3500     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3501
3502     /* check that the value is modified in hklm classes */
3503     res = RegQueryValueExA(hklm, "val2", NULL, &type, (LPBYTE)buffer, &size);
3504     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3505     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3506
3507     if (RegCreateKeyExA( HKEY_CURRENT_USER, "Software\\Classes\\WineTestCls", 0, NULL, 0,
3508                          KEY_QUERY_VALUE|KEY_SET_VALUE, NULL, &hkey, NULL )) return;
3509     ok(!IS_HKCR(hkey), "hkcr mask set in %p\n", hkey);
3510
3511     /* try to open that key in hkcr */
3512     res = RegOpenKeyExA( HKEY_CLASSES_ROOT, "WineTestCls", 0,
3513                          KEY_QUERY_VALUE|KEY_SET_VALUE, &hkcr );
3514     ok(res == ERROR_SUCCESS,
3515        "test key not found in hkcr: %ld\n", res);
3516     ok(IS_HKCR(hkcr), "hkcr mask not set in %p\n", hkcr);
3517
3518     /* set a value in user's classes */
3519     res = RegSetValueExA(hkey, "val2", 0, REG_SZ, (const BYTE *)"user", sizeof("user"));
3520     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3521
3522     /* try to find the value in hkcr */
3523     res = RegQueryValueExA(hkcr, "val2", NULL, &type, (LPBYTE)buffer, &size);
3524     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3525     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3526
3527     /* modify the value in hklm */
3528     res = RegSetValueExA(hklm, "val2", 0, REG_SZ, (const BYTE *)"hklm", sizeof("hklm"));
3529     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3530
3531     /* check that the value is not overwritten in hkcr or user's classes */
3532     res = RegQueryValueExA(hkcr, "val2", NULL, &type, (LPBYTE)buffer, &size);
3533     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3534     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3535     res = RegQueryValueExA(hkey, "val2", NULL, &type, (LPBYTE)buffer, &size);
3536     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3537     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3538
3539     /* modify the value in hkcr */
3540     res = RegSetValueExA(hkcr, "val2", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3541     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3542
3543     /* check that the value is overwritten in hklm and user's classes */
3544     res = RegQueryValueExA(hkcr, "val2", NULL, &type, (LPBYTE)buffer, &size);
3545     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3546     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3547     res = RegQueryValueExA(hkey, "val2", NULL, &type, (LPBYTE)buffer, &size);
3548     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3549     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3550
3551     /* create a subkey in hklm */
3552     if (RegCreateKeyExA( hklm, "subkey1", 0, NULL, 0,
3553                          KEY_QUERY_VALUE|KEY_SET_VALUE, NULL, &hklmsub1, NULL )) return;
3554     ok(!IS_HKCR(hklmsub1), "hkcr mask set in %p\n", hklmsub1);
3555     /* try to open that subkey in hkcr */
3556     res = RegOpenKeyExA( hkcr, "subkey1", 0, KEY_QUERY_VALUE|KEY_SET_VALUE, &hkcrsub1 );
3557     ok(res == ERROR_SUCCESS, "test key not found in hkcr: %ld\n", res);
3558     ok(IS_HKCR(hkcrsub1), "hkcr mask not set in %p\n", hkcrsub1);
3559
3560     /* set a value in hklm classes */
3561     res = RegSetValueExA(hklmsub1, "subval1", 0, REG_SZ, (const BYTE *)"hklm", sizeof("hklm"));
3562     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3563
3564     /* try to find the value in hkcr */
3565     res = RegQueryValueExA(hkcrsub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3566     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3567     ok(!strcmp( buffer, "hklm" ), "value set to '%s'\n", buffer );
3568
3569     /* modify the value in hkcr */
3570     res = RegSetValueExA(hkcrsub1, "subval1", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3571     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3572
3573     /* check that the value is modified in hklm classes */
3574     res = RegQueryValueExA(hklmsub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3575     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3576     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3577
3578     /* create a subkey in user's classes */
3579     if (RegCreateKeyExA( hkey, "subkey1", 0, NULL, 0,
3580                          KEY_QUERY_VALUE|KEY_SET_VALUE, NULL, &hkeysub1, NULL )) return;
3581     ok(!IS_HKCR(hkeysub1), "hkcr mask set in %p\n", hkeysub1);
3582
3583     /* set a value in user's classes */
3584     res = RegSetValueExA(hkeysub1, "subval1", 0, REG_SZ, (const BYTE *)"user", sizeof("user"));
3585     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3586
3587     /* try to find the value in hkcr */
3588     res = RegQueryValueExA(hkcrsub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3589     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3590     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3591
3592     /* modify the value in hklm */
3593     res = RegSetValueExA(hklmsub1, "subval1", 0, REG_SZ, (const BYTE *)"hklm", sizeof("hklm"));
3594     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3595
3596     /* check that the value is not overwritten in hkcr or user's classes */
3597     res = RegQueryValueExA(hkcrsub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3598     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3599     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3600     res = RegQueryValueExA(hkeysub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3601     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3602     ok(!strcmp( buffer, "user" ), "value set to '%s'\n", buffer );
3603
3604     /* modify the value in hkcr */
3605     res = RegSetValueExA(hkcrsub1, "subval1", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3606     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3607
3608     /* check that the value is not overwritten in hklm, but in user's classes */
3609     res = RegQueryValueExA(hklmsub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3610     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3611     ok(!strcmp( buffer, "hklm" ), "value set to '%s'\n", buffer );
3612     res = RegQueryValueExA(hkeysub1, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3613     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3614     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3615
3616     /* new subkey in hkcr */
3617     if (RegCreateKeyExA( hkcr, "subkey2", 0, NULL, 0,
3618                          KEY_QUERY_VALUE|KEY_SET_VALUE, NULL, &hkcrsub2, NULL )) return;
3619     ok(IS_HKCR(hkcrsub2), "hkcr mask not set in %p\n", hkcrsub2);
3620     res = RegSetValueExA(hkcrsub2, "subval1", 0, REG_SZ, (const BYTE *)"hkcr", sizeof("hkcr"));
3621     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld, GLE=%lx\n", res, GetLastError());
3622
3623     /* try to open that new subkey in user's classes and hklm */
3624     res = RegOpenKeyExA( hkey, "subkey2", 0, KEY_QUERY_VALUE|KEY_SET_VALUE, &hklmsub2 );
3625     ok(res != ERROR_SUCCESS, "test key found in user's classes: %ld\n", res);
3626     hklmsub2 = 0;
3627     res = RegOpenKeyExA( hklm, "subkey2", 0, KEY_QUERY_VALUE|KEY_SET_VALUE, &hklmsub2 );
3628     ok(res == ERROR_SUCCESS, "test key not found in hklm: %ld\n", res);
3629     ok(!IS_HKCR(hklmsub2), "hkcr mask set in %p\n", hklmsub2);
3630
3631     /* check that the value is present in hklm */
3632     res = RegQueryValueExA(hklmsub2, "subval1", NULL, &type, (LPBYTE)buffer, &size);
3633     ok(res == ERROR_SUCCESS, "RegQueryValueExA failed: %ld\n", res);
3634     ok(!strcmp( buffer, "hkcr" ), "value set to '%s'\n", buffer );
3635
3636     /* cleanup */
3637     RegCloseKey( hkeysub1 );
3638     RegCloseKey( hklmsub1 );
3639
3640     /* delete subkey1 from hkcr (should point at user's classes) */
3641     res = RegDeleteKeyA(hkcr, "subkey1");
3642     ok(res == ERROR_SUCCESS, "RegDeleteKey failed: %ld\n", res);
3643
3644     /* confirm key was removed in hkey but not hklm */
3645     res = RegOpenKeyExA(hkey, "subkey1", 0, KEY_READ, &hkeysub1);
3646     ok(res == ERROR_FILE_NOT_FOUND, "test key found in user's classes: %ld\n", res);
3647     res = RegOpenKeyExA(hklm, "subkey1", 0, KEY_READ, &hklmsub1);
3648     ok(res == ERROR_SUCCESS, "test key not found in hklm: %ld\n", res);
3649     ok(!IS_HKCR(hklmsub1), "hkcr mask set in %p\n", hklmsub1);
3650
3651     /* delete subkey1 from hkcr again (which should now point at hklm) */
3652     res = RegDeleteKeyA(hkcr, "subkey1");
3653     ok(res == ERROR_SUCCESS, "RegDeleteKey failed: %ld\n", res);
3654
3655     /* confirm hkey was removed in hklm */
3656     RegCloseKey( hklmsub1 );
3657     res = RegOpenKeyExA(hklm, "subkey1", 0, KEY_READ, &hklmsub1);
3658     ok(res == ERROR_FILE_NOT_FOUND, "test key found in hklm: %ld\n", res);
3659
3660     /* final cleanup */
3661     delete_key( hkey );
3662     delete_key( hklm );
3663     delete_key( hkcr );
3664     delete_key( hkeysub1 );
3665     delete_key( hklmsub1 );
3666     delete_key( hkcrsub1 );
3667     delete_key( hklmsub2 );
3668     delete_key( hkcrsub2 );
3669     RegCloseKey( hkey );
3670     RegCloseKey( hklm );
3671     RegCloseKey( hkcr );
3672     RegCloseKey( hkeysub1 );
3673     RegCloseKey( hklmsub1 );
3674     RegCloseKey( hkcrsub1 );
3675     RegCloseKey( hklmsub2 );
3676     RegCloseKey( hkcrsub2 );
3677 }
3678
3679 static void test_classesroot_enum(void)
3680 {
3681     HKEY hkcu=0, hklm=0, hkcr=0, hkcusub[2]={0}, hklmsub[2]={0};
3682     DWORD size;
3683     static CHAR buffer[2];
3684     LONG res;
3685
3686     /* prepare initial testing env in HKCU */
3687     if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Classes\\WineTestCls", &hkcu ))
3688     {
3689         delete_key( hkcu );
3690         RegCloseKey( hkcu );
3691     }
3692     res = RegCreateKeyExA( HKEY_CURRENT_USER, "Software\\Classes\\WineTestCls", 0, NULL, 0,
3693                             KEY_SET_VALUE|KEY_ENUMERATE_SUB_KEYS, NULL, &hkcu, NULL );
3694
3695     if (res != ERROR_SUCCESS)
3696     {
3697         skip("failed to add a user class\n");
3698         return;
3699     }
3700
3701     res = RegOpenKeyA( HKEY_CLASSES_ROOT, "WineTestCls", &hkcr );
3702     todo_wine ok(res == ERROR_SUCCESS ||
3703                  broken(res == ERROR_FILE_NOT_FOUND /* WinNT */),
3704                  "test key not found in hkcr: %ld\n", res);
3705     if (res)
3706     {
3707         skip("HKCR key merging not supported\n");
3708         delete_key( hkcu );
3709         RegCloseKey( hkcu );
3710         return;
3711     }
3712
3713     res = RegSetValueExA( hkcu, "X", 0, REG_SZ, (const BYTE *) "AA", 3 );
3714     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", res);
3715     res = RegSetValueExA( hkcu, "Y", 0, REG_SZ, (const BYTE *) "B", 2 );
3716     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", res);
3717     res = RegCreateKeyA( hkcu, "A", &hkcusub[0] );
3718     ok(res == ERROR_SUCCESS, "RegCreateKeyA failed: %ld\n", res);
3719     res = RegCreateKeyA( hkcu, "B", &hkcusub[1] );
3720     ok(res == ERROR_SUCCESS, "RegCreateKeyA failed: %ld\n", res);
3721
3722     /* test on values in HKCU */
3723     size = sizeof(buffer);
3724     res = RegEnumValueA( hkcr, 0, buffer, &size, NULL, NULL, NULL, NULL );
3725     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3726     ok(!strcmp( buffer, "X" ), "expected 'X', got '%s'\n", buffer);
3727     size = sizeof(buffer);
3728     res = RegEnumValueA( hkcr, 1, buffer, &size, NULL, NULL, NULL, NULL );
3729     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3730     ok(!strcmp( buffer, "Y" ), "expected 'Y', got '%s'\n", buffer);
3731     size = sizeof(buffer);
3732     res = RegEnumValueA( hkcr, 2, buffer, &size, NULL, NULL, NULL, NULL );
3733     ok(res == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %ld\n", res );
3734
3735     res = RegEnumKeyA( hkcr, 0, buffer, size );
3736     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3737     ok(!strcmp( buffer, "A" ), "expected 'A', got '%s'\n", buffer);
3738     res = RegEnumKeyA( hkcr, 1, buffer, size );
3739     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3740     ok(!strcmp( buffer, "B" ), "expected 'B', got '%s'\n", buffer);
3741     res = RegEnumKeyA( hkcr, 2, buffer, size );
3742     ok(res == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %ld\n", res );
3743
3744     /* prepare test env in HKLM */
3745     if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Classes\\WineTestCls", &hklm ))
3746     {
3747         delete_key( hklm );
3748         RegCloseKey( hklm );
3749     }
3750
3751     res = RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Classes\\WineTestCls", 0, NULL, 0,
3752                             KEY_SET_VALUE|KEY_ENUMERATE_SUB_KEYS, NULL, &hklm, NULL );
3753
3754     if (res == ERROR_ACCESS_DENIED)
3755     {
3756         RegCloseKey( hkcusub[0] );
3757         RegCloseKey( hkcusub[1] );
3758         delete_key( hkcu );
3759         RegCloseKey( hkcu );
3760         RegCloseKey( hkcr );
3761         skip("not enough privileges to add a system class\n");
3762         return;
3763     }
3764
3765     res = RegSetValueExA( hklm, "X", 0, REG_SZ, (const BYTE *) "AB", 3 );
3766     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", res);
3767     res = RegSetValueExA( hklm, "Z", 0, REG_SZ, (const BYTE *) "C", 2 );
3768     ok(res == ERROR_SUCCESS, "RegSetValueExA failed: %ld\n", res);
3769     res = RegCreateKeyA( hklm, "A", &hklmsub[0] );
3770     ok(res == ERROR_SUCCESS, "RegCreateKeyA failed: %ld\n", res);
3771     res = RegCreateKeyA( hklm, "C", &hklmsub[1] );
3772     ok(res == ERROR_SUCCESS, "RegCreateKeyA failed: %ld\n", res);
3773
3774     /* test on values/keys in both HKCU and HKLM */
3775     size = sizeof(buffer);
3776     res = RegEnumValueA( hkcr, 0, buffer, &size, NULL, NULL, NULL, NULL );
3777     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3778     ok(!strcmp( buffer, "X" ), "expected 'X', got '%s'\n", buffer);
3779     size = sizeof(buffer);
3780     res = RegEnumValueA( hkcr, 1, buffer, &size, NULL, NULL, NULL, NULL );
3781     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3782     ok(!strcmp( buffer, "Y" ), "expected 'Y', got '%s'\n", buffer);
3783     size = sizeof(buffer);
3784     res = RegEnumValueA( hkcr, 2, buffer, &size, NULL, NULL, NULL, NULL );
3785     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3786     ok(!strcmp( buffer, "Z" ), "expected 'Z', got '%s'\n", buffer);
3787     size = sizeof(buffer);
3788     res = RegEnumValueA( hkcr, 3, buffer, &size, NULL, NULL, NULL, NULL );
3789     ok(res == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %ld\n", res );
3790
3791     res = RegEnumKeyA( hkcr, 0, buffer, size );
3792     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3793     ok(!strcmp( buffer, "A" ), "expected 'A', got '%s'\n", buffer);
3794     res = RegEnumKeyA( hkcr, 1, buffer, size );
3795     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3796     ok(!strcmp( buffer, "B" ), "expected 'B', got '%s'\n", buffer);
3797     res = RegEnumKeyA( hkcr, 2, buffer, size );
3798     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3799     ok(!strcmp( buffer, "C" ), "expected 'C', got '%s'\n", buffer);
3800     res = RegEnumKeyA( hkcr, 3, buffer, size );
3801     ok(res == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %ld\n", res );
3802
3803     /* delete values/keys from HKCU to test only on HKLM */
3804     RegCloseKey( hkcusub[0] );
3805     RegCloseKey( hkcusub[1] );
3806     delete_key( hkcu );
3807     RegCloseKey( hkcu );
3808
3809     size = sizeof(buffer);
3810     res = RegEnumValueA( hkcr, 0, buffer, &size, NULL, NULL, NULL, NULL );
3811     ok(res == ERROR_KEY_DELETED ||
3812        res == ERROR_NO_SYSTEM_RESOURCES, /* Windows XP */
3813        "expected ERROR_KEY_DELETED, got %ld\n", res);
3814     size = sizeof(buffer);
3815     res = RegEnumKeyA( hkcr, 0, buffer, size );
3816     ok(res == ERROR_KEY_DELETED ||
3817        res == ERROR_NO_SYSTEM_RESOURCES, /* Windows XP */
3818        "expected ERROR_KEY_DELETED, got %ld\n", res);
3819
3820     /* reopen HKCR handle */
3821     RegCloseKey( hkcr );
3822     res = RegOpenKeyA( HKEY_CLASSES_ROOT, "WineTestCls", &hkcr );
3823     ok(res == ERROR_SUCCESS, "test key not found in hkcr: %ld\n", res);
3824     if (res) goto cleanup;
3825
3826     /* test on values/keys in HKLM */
3827     size = sizeof(buffer);
3828     res = RegEnumValueA( hkcr, 0, buffer, &size, NULL, NULL, NULL, NULL );
3829     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3830     ok(!strcmp( buffer, "X" ), "expected 'X', got '%s'\n", buffer);
3831     size = sizeof(buffer);
3832     res = RegEnumValueA( hkcr, 1, buffer, &size, NULL, NULL, NULL, NULL );
3833     ok(res == ERROR_SUCCESS, "RegEnumValueA failed: %ld\n", res );
3834     ok(!strcmp( buffer, "Z" ), "expected 'Z', got '%s'\n", buffer);
3835     size = sizeof(buffer);
3836     res = RegEnumValueA( hkcr, 2, buffer, &size, NULL, NULL, NULL, NULL );
3837     ok(res == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %ld\n", res );
3838
3839     res = RegEnumKeyA( hkcr, 0, buffer, size );
3840     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3841     ok(!strcmp( buffer, "A" ), "expected 'A', got '%s'\n", buffer);
3842     res = RegEnumKeyA( hkcr, 1, buffer, size );
3843     ok(res == ERROR_SUCCESS, "RegEnumKey failed: %ld\n", res );
3844     ok(!strcmp( buffer, "C" ), "expected 'C', got '%s'\n", buffer);
3845     res = RegEnumKeyA( hkcr, 2, buffer, size );
3846     ok(res == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %ld\n", res );
3847
3848 cleanup:
3849     RegCloseKey( hklmsub[0] );
3850     RegCloseKey( hklmsub[1] );
3851     delete_key( hklm );
3852     RegCloseKey( hklm );
3853     RegCloseKey( hkcr );
3854 }
3855
3856 static void test_classesroot_mask(void)
3857 {
3858     HKEY hkey;
3859     LSTATUS res;
3860
3861     res = RegOpenKeyA( HKEY_CLASSES_ROOT, "CLSID", &hkey );
3862     ok(res == ERROR_SUCCESS, "RegOpenKeyA failed: %ld\n", res);
3863     todo_wine ok(IS_HKCR(hkey) || broken(!IS_HKCR(hkey)) /* WinNT */,
3864                  "hkcr mask not set in %p\n", hkey);
3865     RegCloseKey( hkey );
3866
3867     res = RegOpenKeyA( HKEY_CURRENT_USER, "Software", &hkey );
3868     ok(res == ERROR_SUCCESS, "RegOpenKeyA failed: %ld\n", res);
3869     ok(!IS_HKCR(hkey), "hkcr mask set in %p\n", hkey);
3870     RegCloseKey( hkey );
3871
3872     res = RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software", &hkey );
3873     ok(res == ERROR_SUCCESS, "RegOpenKeyA failed: %ld\n", res);
3874     ok(!IS_HKCR(hkey), "hkcr mask set in %p\n", hkey);
3875     RegCloseKey( hkey );
3876
3877     res = RegOpenKeyA( HKEY_USERS, ".Default", &hkey );
3878     ok(res == ERROR_SUCCESS, "RegOpenKeyA failed: %ld\n", res);
3879     ok(!IS_HKCR(hkey), "hkcr mask set in %p\n", hkey);
3880     RegCloseKey( hkey );
3881
3882     res = RegOpenKeyA( HKEY_CURRENT_CONFIG, "Software", &hkey );
3883     ok(res == ERROR_SUCCESS, "RegOpenKeyA failed: %ld\n", res);
3884     ok(!IS_HKCR(hkey), "hkcr mask set in %p\n", hkey);
3885     RegCloseKey( hkey );
3886 }
3887
3888 static void test_deleted_key(void)
3889 {
3890     HKEY hkey, hkey2;
3891     char value[20];
3892     DWORD val_count, type;
3893     LONG res;
3894
3895     /* Open the test key, then delete it while it's open */
3896     RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Test", &hkey );
3897
3898     delete_key( hkey_main );
3899
3900     val_count = sizeof(value);
3901     type = 0;
3902     res = RegEnumValueA( hkey, 0, value, &val_count, NULL, &type, 0, 0 );
3903     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3904
3905     res = RegEnumKeyA( hkey, 0, value, sizeof(value) );
3906     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3907
3908     val_count = sizeof(value);
3909     type = 0;
3910     res = RegQueryValueExA( hkey, "test", NULL, &type, (BYTE *)value, &val_count );
3911     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3912
3913     res = RegSetValueExA( hkey, "test", 0, REG_SZ, (const BYTE*)"value", 6);
3914     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3915
3916     res = RegOpenKeyA( hkey, "test", &hkey2 );
3917     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3918     if (res == 0)
3919         RegCloseKey( hkey2 );
3920
3921     res = RegCreateKeyA( hkey, "test", &hkey2 );
3922     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3923     if (res == 0)
3924         RegCloseKey( hkey2 );
3925
3926     res = RegFlushKey( hkey );
3927     ok(res == ERROR_KEY_DELETED, "expect ERROR_KEY_DELETED, got %li\n", res);
3928
3929     RegCloseKey( hkey );
3930
3931     setup_main_key();
3932 }
3933
3934 static void test_delete_value(void)
3935 {
3936     LONG res;
3937     char longname[401];
3938
3939     res = RegSetValueExA( hkey_main, "test", 0, REG_SZ, (const BYTE*)"value", 6 );
3940     ok(res == ERROR_SUCCESS, "expect ERROR_SUCCESS, got %li\n", res);
3941
3942     res = RegQueryValueExA( hkey_main, "test", NULL, NULL, NULL, NULL);
3943     ok(res == ERROR_SUCCESS, "expect ERROR_SUCCESS, got %li\n", res);
3944
3945     res = RegDeleteValueA( hkey_main, "test" );
3946     ok(res == ERROR_SUCCESS, "expect ERROR_SUCCESS, got %li\n", res);
3947
3948     res = RegQueryValueExA( hkey_main, "test", NULL, NULL, NULL, NULL);
3949     ok(res == ERROR_FILE_NOT_FOUND, "expect ERROR_FILE_NOT_FOUND, got %li\n", res);
3950
3951     res = RegDeleteValueA( hkey_main, "test" );
3952     ok(res == ERROR_FILE_NOT_FOUND, "expect ERROR_FILE_NOT_FOUND, got %li\n", res);
3953
3954     memset(longname, 'a', 400);
3955     longname[400] = 0;
3956     res = RegDeleteValueA( hkey_main, longname );
3957     ok(res == ERROR_FILE_NOT_FOUND, "expect ERROR_FILE_NOT_FOUND, got %li\n", res);
3958
3959     /* Default registry value */
3960     res = RegSetValueExA(hkey_main, "", 0, REG_SZ, (const BYTE *)"value", 6);
3961     ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res);
3962
3963     res = RegQueryValueExA(hkey_main, "", NULL, NULL, NULL, NULL);
3964     ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res);
3965
3966     res = RegDeleteValueA(hkey_main, "" );
3967     ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", res);
3968
3969     res = RegQueryValueExA(hkey_main, "", NULL, NULL, NULL, NULL);
3970     ok(res == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %ld\n", res);
3971 }
3972
3973 static void test_delete_key_value(void)
3974 {
3975     HKEY subkey;
3976     LONG ret;
3977
3978     if (!pRegDeleteKeyValueA)
3979     {
3980         win_skip("RegDeleteKeyValue is not available.\n");
3981         return;
3982     }
3983
3984     ret = pRegDeleteKeyValueA(NULL, NULL, NULL);
3985     ok(ret == ERROR_INVALID_HANDLE, "got %ld\n", ret);
3986
3987     ret = pRegDeleteKeyValueA(hkey_main, NULL, NULL);
3988     ok(ret == ERROR_FILE_NOT_FOUND, "got %ld\n", ret);
3989
3990     ret = RegSetValueExA(hkey_main, "test", 0, REG_SZ, (const BYTE*)"value", 6);
3991     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
3992
3993     ret = RegQueryValueExA(hkey_main, "test", NULL, NULL, NULL, NULL);
3994     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
3995
3996     /* NULL subkey name means delete from open key */
3997     ret = pRegDeleteKeyValueA(hkey_main, NULL, "test");
3998     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
3999
4000     ret = RegQueryValueExA(hkey_main, "test", NULL, NULL, NULL, NULL);
4001     ok(ret == ERROR_FILE_NOT_FOUND, "got %ld\n", ret);
4002
4003     /* now with real subkey */
4004     ret = RegCreateKeyExA(hkey_main, "Subkey1", 0, NULL, 0, KEY_WRITE|KEY_READ, NULL, &subkey, NULL);
4005     ok(!ret, "failed with error %ld\n", ret);
4006
4007     ret = RegSetValueExA(subkey, "test", 0, REG_SZ, (const BYTE*)"value", 6);
4008     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
4009
4010     ret = RegQueryValueExA(subkey, "test", NULL, NULL, NULL, NULL);
4011     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
4012
4013     ret = pRegDeleteKeyValueA(hkey_main, "Subkey1", "test");
4014     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
4015
4016     ret = RegQueryValueExA(subkey, "test", NULL, NULL, NULL, NULL);
4017     ok(ret == ERROR_FILE_NOT_FOUND, "got %ld\n", ret);
4018
4019     /* Default registry value */
4020     ret = RegSetValueExA(subkey, "", 0, REG_SZ, (const BYTE *)"value", 6);
4021     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4022
4023     ret = RegQueryValueExA(subkey, "", NULL, NULL, NULL, NULL);
4024     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4025
4026     ret = pRegDeleteKeyValueA(hkey_main, "Subkey1", "" );
4027     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4028
4029     ret = RegQueryValueExA(subkey, "", NULL, NULL, NULL, NULL);
4030     ok(ret == ERROR_FILE_NOT_FOUND, "expected ERROR_FILE_NOT_FOUND, got %ld\n", ret);
4031
4032     RegDeleteKeyA(subkey, "");
4033     RegCloseKey(subkey);
4034 }
4035
4036 static void test_RegOpenCurrentUser(void)
4037 {
4038     HKEY key;
4039     LONG ret;
4040
4041     key = HKEY_CURRENT_USER;
4042     ret = RegOpenCurrentUser(KEY_READ, &key);
4043     ok(!ret, "got %ld, error %ld\n", ret, GetLastError());
4044     ok(key != HKEY_CURRENT_USER, "got %p\n", key);
4045     RegCloseKey(key);
4046 }
4047
4048 struct notify_data {
4049     HKEY key;
4050     DWORD flags;
4051     HANDLE event;
4052 };
4053
4054 static DWORD WINAPI notify_change_thread(void *arg)
4055 {
4056     struct notify_data *data = arg;
4057     LONG ret;
4058
4059     ret = RegNotifyChangeKeyValue(data->key, TRUE,
4060             REG_NOTIFY_CHANGE_NAME|data->flags, data->event, TRUE);
4061     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4062     return 0;
4063 }
4064
4065 static void test_RegNotifyChangeKeyValue(void)
4066 {
4067     struct notify_data data;
4068     HKEY key, subkey, subsubkey;
4069     HANDLE thread;
4070     HANDLE event;
4071     DWORD dwret;
4072     LONG ret;
4073
4074     event = CreateEventW(NULL, FALSE, TRUE, NULL);
4075     ok(event != NULL, "CreateEvent failed, error %lu\n", GetLastError());
4076     ret = RegCreateKeyA(hkey_main, "TestKey", &key);
4077     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4078
4079     ret = RegNotifyChangeKeyValue(key, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, event, TRUE);
4080     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4081     dwret = WaitForSingleObject(event, 0);
4082     ok(dwret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %lu\n", dwret);
4083
4084     ret = RegCreateKeyA(key, "SubKey", &subkey);
4085     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4086     dwret = WaitForSingleObject(event, 0);
4087     ok(dwret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", dwret);
4088
4089     /* watching deeper keys */
4090     ret = RegNotifyChangeKeyValue(key, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, event, TRUE);
4091     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4092     dwret = WaitForSingleObject(event, 0);
4093     ok(dwret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %lu\n", dwret);
4094
4095     ret = RegCreateKeyA(subkey, "SubKey", &subsubkey);
4096     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4097     dwret = WaitForSingleObject(event, 0);
4098     ok(dwret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", dwret);
4099
4100     /* watching deeper values */
4101     ret = RegNotifyChangeKeyValue(key, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, event, TRUE);
4102     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4103     dwret = WaitForSingleObject(event, 0);
4104     ok(dwret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %lu\n", dwret);
4105
4106     ret = RegSetValueA(subsubkey, NULL, REG_SZ, "SubSubKeyValue", 0);
4107     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4108     dwret = WaitForSingleObject(event, 0);
4109     ok(dwret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", dwret);
4110
4111     /* don't watch deeper values */
4112     RegCloseKey(key);
4113     ret = RegOpenKeyA(hkey_main, "TestKey", &key);
4114     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4115
4116     ret = RegNotifyChangeKeyValue(key, FALSE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, event, TRUE);
4117     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4118     dwret = WaitForSingleObject(event, 0);
4119     ok(dwret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %lu\n", dwret);
4120
4121     ret = RegSetValueA(subsubkey, NULL, REG_SZ, "SubSubKeyValueNEW", 0);
4122     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4123     dwret = WaitForSingleObject(event, 0);
4124     ok(dwret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %lu\n", dwret);
4125
4126     RegDeleteKeyA(subkey, "SubKey");
4127     RegDeleteKeyA(key, "SubKey");
4128     RegCloseKey(subsubkey);
4129     RegCloseKey(subkey);
4130     RegCloseKey(key);
4131
4132     /* test same thread with REG_NOTIFY_THREAD_AGNOSTIC */
4133     ret = RegOpenKeyA(hkey_main, "TestKey", &key);
4134     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4135     ret = RegNotifyChangeKeyValue(key, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_THREAD_AGNOSTIC,
4136             event, TRUE);
4137     if (ret == ERROR_INVALID_PARAMETER)
4138     {
4139         win_skip("REG_NOTIFY_THREAD_AGNOSTIC is not supported\n");
4140         RegCloseKey(key);
4141         CloseHandle(event);
4142         return;
4143     }
4144
4145     ret = RegCreateKeyA(key, "SubKey", &subkey);
4146     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4147     dwret = WaitForSingleObject(event, 0);
4148     ok(dwret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", dwret);
4149
4150     RegDeleteKeyA(key, "SubKey");
4151     RegCloseKey(subkey);
4152     RegCloseKey(key);
4153
4154     /* test different thread without REG_NOTIFY_THREAD_AGNOSTIC */
4155     ret = RegOpenKeyA(hkey_main, "TestKey", &key);
4156     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4157
4158     data.key = key;
4159     data.flags = 0;
4160     data.event = event;
4161     thread = CreateThread(NULL, 0, notify_change_thread, &data, 0, NULL);
4162     WaitForSingleObject(thread, INFINITE);
4163     CloseHandle(thread);
4164
4165     /* the thread exiting causes event to signal on Windows
4166        this is worked around on Windows using REG_NOTIFY_THREAD_AGNOSTIC
4167        Wine already behaves as if the flag is set */
4168     dwret = WaitForSingleObject(event, 0);
4169     todo_wine
4170     ok(dwret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", dwret);
4171     RegCloseKey(key);
4172
4173     /* test different thread with REG_NOTIFY_THREAD_AGNOSTIC */
4174     ret = RegOpenKeyA(hkey_main, "TestKey", &key);
4175     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4176
4177     data.flags = REG_NOTIFY_THREAD_AGNOSTIC;
4178     thread = CreateThread(NULL, 0, notify_change_thread, &data, 0, NULL);
4179     WaitForSingleObject(thread, INFINITE);
4180     CloseHandle(thread);
4181
4182     dwret = WaitForSingleObject(event, 0);
4183     ok(dwret == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %lu\n", dwret);
4184
4185     ret = RegCreateKeyA(key, "SubKey", &subkey);
4186     ok(ret == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", ret);
4187
4188     dwret = WaitForSingleObject(event, 0);
4189     ok(dwret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", dwret);
4190
4191     RegDeleteKeyA(key, "SubKey");
4192     RegDeleteKeyA(key, "");
4193     RegCloseKey(subkey);
4194     RegCloseKey(key);
4195     CloseHandle(event);
4196 }
4197
4198 static const char *find_counter_value(const char *text, const char *index)
4199 {
4200     const char *p = text;
4201
4202     while (*p)
4203     {
4204         if (!strcmp(p, index))
4205             return p + strlen(p) + 1;
4206
4207         p += strlen(p) + 1;
4208         p += strlen(p) + 1;
4209     }
4210
4211     return NULL;
4212 }
4213
4214 static void test_counter_values(const char *text, HKEY key)
4215 {
4216     const char *p = text;
4217     const char *name;
4218
4219     ok(!strcmp(p, "1"), "got first index %s\n", debugstr_a(p));
4220     p += strlen(p) + 1;
4221     ok(!strcmp(p, "1847"), "got first name %s\n", debugstr_a(p));
4222     p += strlen(p) + 1;
4223
4224     while (*p)
4225     {
4226         unsigned int index = atoi(p);
4227
4228         ok(index > 0, "expected nonzero index\n");
4229
4230         p += strlen(p) + 1;
4231         ok(*p, "name missing for %u\n", index);
4232         p += strlen(p) + 1;
4233     }
4234
4235     name = find_counter_value(text, "1846");
4236     ok(name != NULL, "did not find name\n");
4237     if (key != HKEY_PERFORMANCE_NLSTEXT)
4238         ok(!strcmp(name, "End Marker"), "got name %s\n", debugstr_a(name));
4239 }
4240
4241 static void test_help_values(const char *text, HKEY key)
4242 {
4243     const char *p = text;
4244     const char *name;
4245
4246     while (*p)
4247     {
4248         unsigned int index = atoi(p);
4249
4250         ok(index > 0, "expected nonzero index\n");
4251
4252         p += strlen(p) + 1;
4253         p += strlen(p) + 1;
4254     }
4255
4256     name = find_counter_value(text, "1847");
4257     ok(name != NULL, "did not find name\n");
4258     if (key != HKEY_PERFORMANCE_NLSTEXT)
4259         ok(!strcmp(name, "End Marker"), "got name %s\n", debugstr_a(name));
4260 }
4261
4262 static void test_performance_keys(void)
4263 {
4264     static const HKEY keys[] = {HKEY_PERFORMANCE_DATA, HKEY_PERFORMANCE_TEXT, HKEY_PERFORMANCE_NLSTEXT};
4265     static const char *const names[] = {NULL, "", "Global", "2", "invalid counter name", "System"};
4266     DWORD size, type, sysname_len, expect_size, key_count, value_count;
4267     LARGE_INTEGER perftime1, perftime2, systime1, systime2, freq;
4268     WCHAR sysname[MAX_COMPUTERNAME_LENGTH + 1];
4269     unsigned int buffer_size = 1024 * 1024;
4270     void *buffer, *bufferW;
4271     PERF_DATA_BLOCK *data;
4272     union
4273     {
4274         FILETIME f;
4275         LONGLONG l;
4276     } file_time;
4277     unsigned int i, j;
4278     HKEY key;
4279     LONG ret;
4280
4281     buffer = malloc(buffer_size);
4282
4283     sysname_len = ARRAY_SIZE(sysname);
4284     GetComputerNameW(sysname, &sysname_len);
4285
4286     for (i = 0; i < ARRAY_SIZE(keys); ++i)
4287     {
4288         winetest_push_context("key %p", keys[i]);
4289
4290         for (j = 0; j < ARRAY_SIZE(names); ++j)
4291         {
4292             winetest_push_context("value %s", debugstr_a(names[j]));
4293
4294             QueryPerformanceFrequency(&freq);
4295
4296             size = 0;
4297             ret = RegQueryValueExA(keys[i], names[j], NULL, NULL, NULL, &size);
4298             ok(ret == ERROR_MORE_DATA, "got %lu\n", ret);
4299             ok(!size, "got size %lu\n", size);
4300
4301             size = 10;
4302             ret = RegQueryValueExA(keys[i], names[j], NULL, NULL, buffer, &size);
4303             ok(ret == ERROR_MORE_DATA, "got %lu\n", ret);
4304             todo_wine
4305                 ok(size == 10, "got size %lu\n", size);
4306
4307             size = buffer_size;
4308             ret = RegQueryValueExA(keys[i], names[j], NULL, NULL, NULL, &size);
4309             ok(ret == ERROR_MORE_DATA, "got %lu\n", ret);
4310
4311             QueryPerformanceCounter(&perftime1);
4312             NtQuerySystemTime(&systime1);
4313
4314             size = buffer_size;
4315             type = 0xdeadbeef;
4316             ret = RegQueryValueExA(keys[i], names[j], NULL, &type, buffer, &size);
4317             ok(!ret, "got %lu\n", ret);
4318             ok(type == REG_BINARY, "got type %lu\n", type);
4319             ok(size >= sizeof(PERF_DATA_BLOCK) && size < buffer_size, "got size %lu\n", size);
4320
4321             QueryPerformanceCounter(&perftime2);
4322             NtQuerySystemTime(&systime2);
4323
4324             data = buffer;
4325             ok(!wcsncmp(data->Signature, L"PERF", 4), "got signature %s\n",
4326                     debugstr_wn(data->Signature, 4));
4327             ok(data->LittleEndian == 1, "got endianness %lu\n", data->LittleEndian);
4328             ok(data->Version == 1, "got version %lu\n", data->Version);
4329             ok(data->Revision == 1, "got version %lu\n", data->Revision);
4330             ok(data->TotalByteLength == size, "expected size %lu, got %lu\n",
4331                     size, data->TotalByteLength);
4332
4333             expect_size = sizeof(PERF_DATA_BLOCK) + data->SystemNameLength;
4334             expect_size = (expect_size + 7) & ~7;
4335
4336             ok(data->HeaderLength == expect_size, "expected header size %lu, got %lu\n",
4337                     expect_size, data->HeaderLength);
4338             /* todo: test objects... */
4339             todo_wine ok(data->DefaultObject == 238, "got default object %lu\n", data->DefaultObject);
4340
4341             ok(data->PerfTime.QuadPart >= perftime1.QuadPart
4342                     && data->PerfTime.QuadPart <= perftime2.QuadPart,
4343                     "got times %I64d, %I64d, %I64d\n",
4344                     perftime1.QuadPart, data->PerfTime.QuadPart, perftime2.QuadPart);
4345             ok(data->PerfFreq.QuadPart == freq.QuadPart, "expected frequency %I64d, got %I64d\n",
4346                     freq.QuadPart, data->PerfFreq.QuadPart);
4347             ok(data->PerfTime100nSec.QuadPart >= systime1.QuadPart
4348                     && data->PerfTime100nSec.QuadPart <= systime2.QuadPart,
4349                     "got times %I64d, %I64d, %I64d\n",
4350                     systime1.QuadPart, data->PerfTime100nSec.QuadPart, systime2.QuadPart);
4351             SystemTimeToFileTime(&data->SystemTime, &file_time.f);
4352             /* SYSTEMTIME has a granularity of 1 ms */
4353             ok(file_time.l >= systime1.QuadPart - 10000 && file_time.l <= systime2.QuadPart,
4354                     "got times %I64d, %I64d, %I64d\n", systime1.QuadPart, file_time.l, systime2.QuadPart);
4355
4356             ok(data->SystemNameLength == (sysname_len + 1) * sizeof(WCHAR), "got %lu\n", data->SystemNameLength);
4357             ok(data->SystemNameOffset == sizeof(PERF_DATA_BLOCK),
4358                     "got name offset %lu\n", data->SystemNameOffset);
4359             ok(!wcscmp(sysname, (const WCHAR *)(data + 1)), "expected name %s, got %s\n",
4360                     debugstr_w(sysname), debugstr_w((const WCHAR *)(data + 1)));
4361
4362             winetest_pop_context();
4363         }
4364
4365         /* test the "Counter" value */
4366
4367         size = 0xdeadbeef;
4368         ret = RegQueryValueExA(keys[i], "cOuNtEr", NULL, NULL, NULL, &size);
4369         ok(!ret, "got %lu\n", ret);
4370         ok(size > 0 && size < 0xdeadbeef, "got size %lu\n", size);
4371
4372         type = 0xdeadbeef;
4373         size = 0;
4374         ret = RegQueryValueExA(keys[i], "cOuNtEr", NULL, &type, buffer, &size);
4375         ok(ret == ERROR_MORE_DATA, "got %lu\n", ret);
4376         ok(size > 0, "got size %lu\n", size);
4377
4378         type = 0xdeadbeef;
4379         size = buffer_size;
4380         ret = RegQueryValueExA(keys[i], "cOuNtEr", NULL, &type, buffer, &size);
4381         ok(!ret, "got %lu\n", ret);
4382         ok(type == REG_MULTI_SZ, "got type %lu\n", type);
4383         test_counter_values(buffer, keys[i]);
4384
4385         type = 0xdeadbeef;
4386         size = buffer_size;
4387         ret = RegQueryValueExA(keys[i], "cOuNtErwine", NULL, &type, buffer, &size);
4388         ok(!ret, "got %lu\n", ret);
4389         ok(type == REG_MULTI_SZ, "got type %lu\n", type);
4390         test_counter_values(buffer, keys[i]);
4391
4392         size = 0;
4393         ret = RegQueryValueExW(keys[i], L"cOuNtEr", NULL, NULL, NULL, &size);
4394         ok(!ret, "got %lu\n", ret);
4395         ok(size > 0, "got size %lu\n", size);
4396
4397         bufferW = malloc(size);
4398
4399         type = 0xdeadbeef;
4400         ret = RegQueryValueExW(keys[i], L"cOuNtEr", NULL, &type, bufferW, &size);
4401         ok(!ret, "got %lu\n", ret);
4402         ok(type == REG_MULTI_SZ, "got type %lu\n", type);
4403         WideCharToMultiByte(CP_ACP, 0, bufferW, size / sizeof(WCHAR), buffer, buffer_size, NULL, NULL);
4404         test_counter_values(buffer, keys[i]);
4405
4406         /* test the "Help" value */
4407
4408         size = 0xdeadbeef;
4409         ret = RegQueryValueExA(keys[i], "hElP", NULL, NULL, NULL, &size);
4410         ok(!ret, "got %lu\n", ret);
4411         ok(size > 0 && size < 0xdeadbeef, "got size %lu\n", size);
4412
4413         type = 0xdeadbeef;
4414         size = 0;
4415         ret = RegQueryValueExA(keys[i], "hElP", NULL, &type, buffer, &size);
4416         ok(ret == ERROR_MORE_DATA, "got %lu\n", ret);
4417         ok(size > 0, "got size %lu\n", size);
4418
4419         type = 0xdeadbeef;
4420         size = buffer_size;
4421         ret = RegQueryValueExA(keys[i], "hElP", NULL, &type, buffer, &size);
4422         test_help_values(buffer, keys[i]);
4423
4424         type = 0xdeadbeef;
4425         size = buffer_size;
4426         ret = RegQueryValueExA(keys[i], "hElPwine", NULL, &type, buffer, &size);
4427         ok(!ret, "got %lu\n", ret);
4428         ok(type == REG_MULTI_SZ, "got type %lu\n", type);
4429         test_help_values(buffer, keys[i]);
4430
4431         size = 0;
4432         ret = RegQueryValueExW(keys[i], L"hElP", NULL, NULL, NULL, &size);
4433         ok(!ret, "got %lu\n", ret);
4434         ok(size > 0, "got size %lu\n", size);
4435
4436         bufferW = malloc(size);
4437
4438         type = 0xdeadbeef;
4439         ret = RegQueryValueExW(keys[i], L"hElP", NULL, &type, bufferW, &size);
4440         ok(!ret, "got %lu\n", ret);
4441         ok(type == REG_MULTI_SZ, "got type %lu\n", type);
4442         WideCharToMultiByte(CP_ACP, 0, bufferW, size / sizeof(WCHAR), buffer, buffer_size, NULL, NULL);
4443         test_help_values(buffer, keys[i]);
4444
4445         /* test other registry APIs */
4446
4447         ret = RegOpenKeyA(keys[i], NULL, &key);
4448         todo_wine ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4449
4450         ret = RegOpenKeyA(keys[i], "Global", &key);
4451         ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4452
4453         ret = RegOpenKeyExA(keys[i], "Global", 0, KEY_READ, &key);
4454         ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4455
4456         size = 0;
4457         ret = RegQueryValueA(keys[i], "Global", NULL, (LONG *)&size);
4458         ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4459
4460         ret = RegSetValueA(keys[i], "Global", REG_SZ, "dummy", 5);
4461         ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4462
4463         key_count = 0x900ddeed;
4464         ret = RegQueryInfoKeyA(keys[i], NULL, NULL, NULL, &key_count, NULL,
4465                 NULL, &value_count, NULL, NULL, NULL, NULL);
4466         todo_wine ok(!ret, "got %lu\n", ret);
4467         todo_wine ok(!key_count, "got %lu subkeys\n", key_count);
4468         todo_wine ok(value_count == 2, "got %lu values\n", value_count);
4469
4470         size = buffer_size;
4471         ret = RegEnumValueA(keys[i], 0, buffer, &size, NULL, NULL, NULL, NULL);
4472         todo_wine ok(ret == ERROR_MORE_DATA, "got %lu\n", ret);
4473         ok(size == buffer_size, "got size %lu\n", size);
4474
4475         ret = RegCloseKey(keys[i]);
4476         ok(!ret, "got %lu\n", ret);
4477
4478         ret = RegCloseKey(keys[i]);
4479         ok(!ret, "got %lu\n", ret);
4480
4481         winetest_pop_context();
4482     }
4483
4484     ret = RegSetValueExA(HKEY_PERFORMANCE_DATA, "Global", 0, REG_SZ, (const BYTE *)"dummy", 5);
4485     ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4486
4487     ret = RegSetValueExA(HKEY_PERFORMANCE_TEXT, "Global", 0, REG_SZ, (const BYTE *)"dummy", 5);
4488     todo_wine ok(ret == ERROR_BADKEY, "got %lu\n", ret);
4489
4490     ret = RegSetValueExA(HKEY_PERFORMANCE_NLSTEXT, "Global", 0, REG_SZ, (const BYTE *)"dummy", 5);
4491     todo_wine ok(ret == ERROR_BADKEY, "got %lu\n", ret);
4492
4493     if (pRegSetKeyValueW)
4494     {
4495         ret = pRegSetKeyValueW(HKEY_PERFORMANCE_DATA, NULL, L"Global", REG_SZ, L"dummy", 10);
4496         ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4497
4498         ret = pRegSetKeyValueW(HKEY_PERFORMANCE_TEXT, NULL, L"Global", REG_SZ, L"dummy", 10);
4499         todo_wine ok(ret == ERROR_BADKEY, "got %lu\n", ret);
4500
4501         ret = pRegSetKeyValueW(HKEY_PERFORMANCE_NLSTEXT, NULL, L"Global", REG_SZ, L"dummy", 10);
4502         todo_wine ok(ret == ERROR_BADKEY, "got %lu\n", ret);
4503     }
4504
4505     ret = RegEnumKeyA(HKEY_PERFORMANCE_DATA, 0, buffer, buffer_size);
4506     ok(ret == ERROR_INVALID_HANDLE, "got %lu\n", ret);
4507
4508     ret = RegEnumKeyA(HKEY_PERFORMANCE_TEXT, 0, buffer, buffer_size);
4509     todo_wine ok(ret == ERROR_NO_MORE_ITEMS, "got %lu\n", ret);
4510
4511     ret = RegEnumKeyA(HKEY_PERFORMANCE_NLSTEXT, 0, buffer, buffer_size);
4512     todo_wine ok(ret == ERROR_NO_MORE_ITEMS, "got %lu\n", ret);
4513
4514     free(buffer);
4515 }
4516
4517 static void test_perflib_key(void)
4518 {
4519     unsigned int primary_lang = PRIMARYLANGID(GetUserDefaultLangID());
4520     unsigned int buffer_size = 1024 * 1024;
4521     OBJECT_NAME_INFORMATION *name_info;
4522     HKEY perflib_key, key, key2;
4523     OBJECT_ATTRIBUTES attr;
4524     UNICODE_STRING string;
4525     char lang_name[5];
4526     const char *knames[2] = {"009", "CurrentLanguage"};
4527     char *buffer;
4528     DWORD size;
4529     LONG ret, l;
4530
4531     ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
4532             "Software\\Microsoft\\Windows NT\\CurrentVersion\\Perflib", 0, KEY_READ, &perflib_key);
4533     ok(!ret, "got %lu\n", ret);
4534
4535     ret = RegOpenKeyExA(perflib_key, "009", 0, KEY_READ, &key);
4536     ok(!ret, "got %lu\n", ret);
4537     /* English always returns TEXT; most other languages return NLSTEXT, but
4538      * some (e.g. Hindi) return TEXT */
4539     ok(key == HKEY_PERFORMANCE_TEXT || key == HKEY_PERFORMANCE_NLSTEXT, "got key %p\n", key);
4540
4541     ret = RegCloseKey(key);
4542     ok(!ret, "got %lu\n", ret);
4543
4544     RtlInitUnicodeString(&string, L"009");
4545     InitializeObjectAttributes(&attr, &string, OBJ_CASE_INSENSITIVE, perflib_key, NULL);
4546     ret = NtOpenKey((HANDLE *)&key, KEY_ALL_ACCESS, &attr);
4547     ok(ret == STATUS_PREDEFINED_HANDLE || ret == STATUS_ACCESS_DENIED
4548             || ret == STATUS_SUCCESS /* Win < 7 */, "got %#lx\n", ret);
4549     if (ret == STATUS_PREDEFINED_HANDLE)
4550         ok(!is_special_key(key), "expected a normal handle, got %p\n", key);
4551     else if (ret == STATUS_SUCCESS)
4552         ok(key == HKEY_PERFORMANCE_TEXT, "got key %p\n", key);
4553     else
4554     {
4555         skip("Not enough permissions to test the perflib key.\n");
4556         RegCloseKey(perflib_key);
4557         return;
4558     }
4559
4560     buffer = malloc(buffer_size);
4561
4562     ret = NtQueryKey(key, KeyFullInformation, buffer, buffer_size, &size);
4563     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4564
4565     ret = NtEnumerateKey(key, 0, KeyFullInformation, buffer, buffer_size, &size);
4566     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4567
4568     RtlInitUnicodeString(&string, L"counter");
4569     ret = NtQueryValueKey(key, &string, KeyValuePartialInformation, buffer, buffer_size, &size);
4570     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4571
4572     ret = NtEnumerateValueKey(key, 0, KeyValuePartialInformation, buffer, buffer_size, &size);
4573     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4574
4575     ret = NtSetValueKey(key, &string, 0, REG_SZ, "test", 5);
4576     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4577
4578     ret = NtDeleteValueKey(key, &string);
4579     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4580
4581     ret = NtDeleteKey(key);
4582     ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4583
4584     RtlInitUnicodeString(&string, L"subkey");
4585     InitializeObjectAttributes(&attr, &string, OBJ_CASE_INSENSITIVE, key, NULL);
4586     ret = NtOpenKey((HANDLE *)&key2, KEY_READ, &attr);
4587     if (is_special_key(key))
4588         ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4589     else
4590         ok(ret == STATUS_OBJECT_NAME_NOT_FOUND
4591                 || broken(ret == STATUS_INVALID_HANDLE) /* WoW64 */, "got %#lx\n", ret);
4592
4593     ret = NtCreateKey((HANDLE *)&key2, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL);
4594     if (is_special_key(key))
4595         ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4596     else
4597         ok(!ret || broken(ret == STATUS_ACCESS_DENIED) /* w8adm */
4598                 || broken(ret == STATUS_INVALID_HANDLE) /* WoW64 */, "got %#lx\n", ret);
4599     if (!ret)
4600     {
4601         NtDeleteKey(key2);
4602         NtClose(key2);
4603     }
4604
4605     /* it's a real handle, though */
4606     ret = NtQueryObject(key, ObjectNameInformation, buffer, buffer_size, &size);
4607     if (is_special_key(key))
4608         ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4609     else
4610         ok(!ret, "got %#lx\n", ret);
4611     if (!ret)
4612     {
4613         name_info = (OBJECT_NAME_INFORMATION *)buffer;
4614         ok(!wcsicmp(name_info->Name.Buffer, L"\\REGISTRY\\MACHINE\\SOFTWARE\\Microsoft\\Windows NT"
4615                 "\\CurrentVersion\\Perflib\\009"), "got name %s\n", debugstr_w(name_info->Name.Buffer));
4616     }
4617
4618     ret = NtClose(key);
4619     if (is_special_key(key))
4620         ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4621     else
4622         ok(!ret, "got %#lx\n", ret);
4623
4624     for (l = 0; l < ARRAY_SIZE(knames); l++)
4625     {
4626         winetest_push_context("%ld", l);
4627       todo_wine_if(l == 1) {
4628         ret = RegOpenKeyExA(perflib_key, knames[l], 0, KEY_READ, &key);
4629         ok(!ret, "got %lu\n", ret);
4630         if (is_special_key(key))
4631         {
4632             size = buffer_size;
4633             ret = RegQueryValueExA(key, "counter", NULL, NULL, (BYTE *)buffer, &size);
4634             ok(!ret, "got %lu\n", ret);
4635             if (!ret)
4636             {
4637                 char *str;
4638                 int c = 0;
4639                 for (str = buffer; *str; str += strlen(str) + 1)
4640                     c++;
4641                 /* Note that the two keys may not have the same number of
4642                  * entries if they are in different languages.
4643                  */
4644                 ok(c >= 2 && (c % 2) == 0, "%d is not a valid number of entries in %s\n", c, knames[l]);
4645                 trace("%s has %d entries\n", knames[l], c);
4646             }
4647         }
4648         else
4649         {
4650             /* Windows 7 does not always return a special key for 009
4651              * when running without elevated privileges.
4652              */
4653             ok(broken(l == 0), "expected a special handle, got %p\n", key);
4654         }
4655
4656         ret = RegCloseKey(key);
4657         ok(!ret, "got %lu\n", ret);
4658       }
4659         winetest_pop_context();
4660     }
4661
4662     /* multilingual support was not really completely thought through */
4663     switch (primary_lang)
4664     {
4665     case LANG_PORTUGUESE:
4666     case LANG_CHINESE:
4667         sprintf(lang_name, "%04x", GetUserDefaultLangID());
4668         break;
4669     default:
4670         sprintf(lang_name, "%03x", primary_lang);
4671         break;
4672     }
4673     if (primary_lang != LANG_ENGLISH &&
4674         !RegOpenKeyExA(perflib_key, lang_name, 0, KEY_READ, &key))
4675     {
4676         ok(!is_special_key(key), "expected a normal handle, got %p\n", key);
4677
4678         size = buffer_size;
4679         ret = RegQueryValueExA(key, "counter", NULL, NULL, (BYTE *)buffer, &size);
4680         todo_wine ok(ret == ERROR_FILE_NOT_FOUND, "got %lu\n", ret);
4681
4682         ret = RegCloseKey(key);
4683         todo_wine ok(!ret, "got %lu\n", ret);
4684     }
4685     /* else some languages don't have their own key. The keys are not really
4686      * usable anyway so assume it does not really matter.
4687      */
4688
4689     ret = RegCloseKey(perflib_key);
4690     ok(!ret, "got %lu\n", ret);
4691
4692     RtlInitUnicodeString(&string, L"\\Registry\\PerfData");
4693     InitializeObjectAttributes(&attr, &string, OBJ_CASE_INSENSITIVE, NULL, NULL);
4694     ret = NtOpenKey((HANDLE *)&key, KEY_READ, &attr);
4695     ok(ret == STATUS_OBJECT_NAME_NOT_FOUND, "got %#lx\n", ret);
4696
4697     free(buffer);
4698 }
4699
4700 static void test_RegLoadMUIString(void)
4701 {
4702     HMODULE hUser32, hResDll, hFile;
4703     int (WINAPI *pLoadStringW)(HMODULE, UINT, WCHAR *, int);
4704     LONG ret;
4705     HKEY hkey;
4706     DWORD type, size, text_size;
4707     UINT i;
4708     char buf[64], *p, sysdir[MAX_PATH];
4709     char with_env_var[128], filename[MAX_PATH], tmp_path[MAX_PATH];
4710     WCHAR textW[64], bufW[64];
4711     WCHAR curdirW[MAX_PATH], sysdirW[MAX_PATH];
4712     const static char tz_value[] = "MUI_Std";
4713     const static WCHAR tz_valueW[] = L"MUI_Std";
4714     struct {
4715         const char* value;
4716         DWORD type;
4717         BOOL use_sysdir;
4718         DWORD expected;
4719         DWORD broken_ret;
4720     } test_case[] = {
4721         /* 0 */
4722         { "",                  REG_SZ,        FALSE, ERROR_INVALID_DATA },
4723         { "not a MUI string",  REG_SZ,        FALSE, ERROR_INVALID_DATA },
4724         { "@unknown.dll",      REG_SZ,        TRUE,  ERROR_INVALID_DATA },
4725         { "@unknown.dll,-10",  REG_SZ,        TRUE,  ERROR_FILE_NOT_FOUND },
4726         /*  4 */
4727         { with_env_var,        REG_SZ,        FALSE, ERROR_SUCCESS },
4728         { with_env_var,        REG_EXPAND_SZ, FALSE, ERROR_SUCCESS },
4729         { "%WineMuiTest1%",    REG_EXPAND_SZ, TRUE,  ERROR_INVALID_DATA },
4730         { "@%WineMuiTest2%",   REG_EXPAND_SZ, TRUE,  ERROR_SUCCESS },
4731         /*  8 */
4732         { "@%WineMuiExe%,a",   REG_SZ,        FALSE, ERROR_INVALID_DATA },
4733         { "@%WineMuiExe%,-4",  REG_SZ,        FALSE, ERROR_NOT_FOUND, ERROR_FILE_NOT_FOUND },
4734         { "@%WineMuiExe%,-39", REG_SZ,        FALSE, ERROR_RESOURCE_NAME_NOT_FOUND },
4735         { "@%WineMuiDat%,-16", REG_EXPAND_SZ, FALSE, ERROR_BAD_EXE_FORMAT, ERROR_FILE_NOT_FOUND },
4736     };
4737
4738     if (!pRegLoadMUIStringA || !pRegLoadMUIStringW)
4739     {
4740         win_skip("RegLoadMUIString is not available\n");
4741         return;
4742     }
4743
4744     hUser32 = LoadLibraryA("user32.dll");
4745     ok(hUser32 != NULL, "cannot load user32.dll\n");
4746     pLoadStringW = (void *)GetProcAddress(hUser32, "LoadStringW");
4747     ok(pLoadStringW != NULL, "failed to get LoadStringW address\n");
4748
4749     ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
4750                         "Software\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\UTC", 0,
4751                         KEY_READ, &hkey);
4752     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
4753
4754     size = ARRAY_SIZE(buf);
4755     ret = RegQueryValueExA(hkey, tz_value, NULL, &type, (BYTE *)buf, &size);
4756     ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
4757     ok(buf[0] == '@', "got %s\n", buf);
4758
4759     /* setup MUI string for tests */
4760     strcpy(with_env_var, "@%windir%\\system32\\");
4761     strcat(with_env_var, &buf[1]);
4762     SetEnvironmentVariableA("WineMuiTest1", buf);
4763     SetEnvironmentVariableA("WineMuiTest2", &buf[1]);
4764
4765     /* load expecting text */
4766     p = strrchr(buf, ',');
4767     *p = '\0';
4768     i = atoi(p + 2); /* skip ',-' */
4769     hResDll = LoadLibraryExA(&buf[1], NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE);
4770     memset(textW, 0xaa, sizeof(textW));
4771     ret = pLoadStringW(hResDll, i, textW, ARRAY_SIZE(textW));
4772     ok(ret > 0, "failed to load string resource\n");
4773     text_size = (ret + 1) * sizeof(WCHAR);
4774     FreeLibrary(hResDll);
4775     FreeLibrary(hUser32);
4776
4777     ret = GetSystemDirectoryW(sysdirW, ARRAY_SIZE(sysdirW));
4778     ok(ret > 0, "GetSystemDirectoryW failed\n");
4779     ret = GetSystemDirectoryA(sysdir, ARRAY_SIZE(sysdir));
4780     ok(ret > 0, "GetSystemDirectoryA failed\n");
4781
4782     /* change the current directory to system32 */
4783     GetCurrentDirectoryW(ARRAY_SIZE(curdirW), curdirW);
4784     SetCurrentDirectoryW(sysdirW);
4785
4786     size = 0xdeadbeef;
4787     ret = pRegLoadMUIStringW(hkey, tz_valueW, NULL, 0, &size, 0, NULL);
4788     ok(ret == ERROR_MORE_DATA, "got %ld, expected ERROR_MORE_DATA\n", ret);
4789     ok(size == text_size, "got %lu, expected %lu\n", size, text_size);
4790
4791     memset(bufW, 0xff, sizeof(bufW));
4792     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, sizeof(WCHAR)+1, &size, 0, NULL);
4793     ok(ret == ERROR_INVALID_PARAMETER, "got %ld, expected ERROR_INVALID_PARAMETER\n", ret);
4794     ok(bufW[0] == 0xffff, "got 0x%04x, expected 0xffff\n", bufW[0]);
4795
4796     size = 0xdeadbeef;
4797     memset(bufW, 0xff, sizeof(bufW));
4798     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, sizeof(WCHAR)*2, &size, 0, NULL);
4799     ok(ret == ERROR_MORE_DATA, "got %ld, expected ERROR_MORE_DATA\n", ret);
4800     ok(size == text_size || broken(size == text_size + sizeof(WCHAR) /* vista */),
4801        "got %lu, expected %lu\n", size, text_size);
4802     ok(bufW[0] == 0xffff, "got 0x%04x, expected 0xffff\n", bufW[0]);
4803
4804     memset(bufW, 0xff, sizeof(bufW));
4805     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, sizeof(WCHAR)*2, &size, REG_MUI_STRING_TRUNCATE, NULL);
4806     ok(ret == ERROR_INVALID_PARAMETER, "got %ld, expected ERROR_INVALID_PARAMETER\n", ret);
4807     ok(bufW[0] == 0xffff, "got 0x%04x, expected 0xffff\n", bufW[0]);
4808
4809     memset(bufW, 0xff, sizeof(bufW));
4810     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, sizeof(WCHAR)*2, NULL, 0xdeadbeef, NULL);
4811     ok(ret == ERROR_INVALID_PARAMETER, "got %ld, expected ERROR_INVALID_PARAMETER\n", ret);
4812     ok(bufW[0] == 0xffff, "got 0x%04x, expected 0xffff\n", bufW[0]);
4813
4814     memset(bufW, 0xff, sizeof(bufW));
4815     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, sizeof(WCHAR)*2, NULL, REG_MUI_STRING_TRUNCATE, NULL);
4816     ok(ret == ERROR_SUCCESS, "got %ld, expected ERROR_SUCCESS\n", ret);
4817     ok(bufW[0] == textW[0], "got 0x%04x, expected 0x%04x\n", bufW[0], textW[0]);
4818     ok(bufW[1] == 0, "got 0x%04x, expected nul\n", bufW[1]);
4819
4820     size = 0xdeadbeef;
4821     memset(bufW, 0xff, sizeof(bufW));
4822     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, ARRAY_SIZE(bufW), &size, 0, NULL);
4823     ok(ret == ERROR_SUCCESS, "got %ld, expected ERROR_SUCCESS\n", ret);
4824     ok(size == text_size, "got %lu, expected %lu\n", size, text_size);
4825     ok(!memcmp(textW, bufW, size), "got %s, expected %s\n",
4826        wine_dbgstr_wn(bufW, size / sizeof(WCHAR)), wine_dbgstr_wn(textW, text_size / sizeof(WCHAR)));
4827
4828     ret = pRegLoadMUIStringA(hkey, tz_value, buf, ARRAY_SIZE(buf), &size, 0, NULL);
4829     ok(ret == ERROR_CALL_NOT_IMPLEMENTED, "got %ld, expected ERROR_CALL_NOT_IMPLEMENTED\n", ret);
4830
4831     /* change the current directory to other than system32 directory */
4832     SetCurrentDirectoryA("\\");
4833
4834     size = 0xdeadbeef;
4835     memset(bufW, 0xff, sizeof(bufW));
4836     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, ARRAY_SIZE(bufW), &size, 0, sysdirW);
4837     ok(ret == ERROR_SUCCESS, "got %ld, expected ERROR_SUCCESS\n", ret);
4838     ok(size == text_size, "got %lu, expected %lu\n", size, text_size);
4839     ok(!memcmp(textW, bufW, size), "got %s, expected %s\n",
4840        wine_dbgstr_wn(bufW, size / sizeof(WCHAR)), wine_dbgstr_wn(textW, text_size / sizeof(WCHAR)));
4841
4842     ret = pRegLoadMUIStringA(hkey, tz_value, buf, ARRAY_SIZE(buf), &size, 0, sysdir);
4843     ok(ret == ERROR_CALL_NOT_IMPLEMENTED, "got %ld, expected ERROR_CALL_NOT_IMPLEMENTED\n", ret);
4844
4845     ret = pRegLoadMUIStringW(hkey, tz_valueW, bufW, ARRAY_SIZE(bufW), &size, 0, NULL);
4846     ok(ret == ERROR_FILE_NOT_FOUND, "got %ld, expected ERROR_FILE_NOT_FOUND\n", ret);
4847
4848     ret = pRegLoadMUIStringA(hkey, tz_value, buf, ARRAY_SIZE(buf), &size, 0, NULL);
4849     ok(ret == ERROR_CALL_NOT_IMPLEMENTED, "got %ld, expected ERROR_CALL_NOT_IMPLEMENTED\n", ret);
4850
4851     RegCloseKey(hkey);
4852
4853     GetModuleFileNameA(NULL, filename, ARRAY_SIZE(filename));
4854     SetEnvironmentVariableA("WineMuiExe", filename);
4855
4856     GetTempPathA(ARRAY_SIZE(tmp_path), tmp_path);
4857     GetTempFileNameA(tmp_path, "mui", 0, filename);
4858     SetEnvironmentVariableA("WineMuiDat", filename);
4859
4860     /* write dummy data to the file, i.e. it's not a PE file. */
4861     hFile = CreateFileA(filename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
4862     ok(hFile != INVALID_HANDLE_VALUE, "can't open %s\n", filename);
4863     WriteFile(hFile, filename, strlen(filename), &size, NULL);
4864     CloseHandle(hFile);
4865
4866     for (i = 0; i < ARRAY_SIZE(test_case); i++)
4867     {
4868         size = test_case[i].value ? strlen(test_case[i].value) + 1 : 0;
4869         ret = RegSetValueExA(hkey_main, tz_value, 0, test_case[i].type,
4870                              (const BYTE *)test_case[i].value, size);
4871         ok(ret == ERROR_SUCCESS, "[%2u] got %ld\n", i, ret);
4872
4873         size = 0xdeadbeef;
4874         memset(bufW, 0xff, sizeof(bufW));
4875         ret = pRegLoadMUIStringW(hkey_main, tz_valueW, bufW, ARRAY_SIZE(bufW),
4876                                  &size, 0,
4877                                  test_case[i].use_sysdir ? sysdirW : NULL);
4878         ok(ret == test_case[i].expected ||
4879            broken(test_case[i].value[0] == '%' && ret == ERROR_SUCCESS /* vista */) ||
4880            broken(test_case[i].broken_ret && ret == test_case[i].broken_ret /* vista */),
4881            "[%2u] expected %ld, got %ld\n", i, test_case[i].expected, ret);
4882         if (ret == ERROR_SUCCESS && test_case[i].expected == ERROR_SUCCESS)
4883         {
4884             ok(size == text_size, "[%2u] got %lu, expected %lu\n", i, size, text_size);
4885             ok(!memcmp(bufW, textW, size), "[%2u] got %s, expected %s\n", i,
4886                wine_dbgstr_wn(bufW, size/sizeof(WCHAR)),
4887                wine_dbgstr_wn(textW, text_size/sizeof(WCHAR)));
4888         }
4889     }
4890
4891     SetCurrentDirectoryW(curdirW);
4892     DeleteFileA(filename);
4893     SetEnvironmentVariableA("WineMuiTest1", NULL);
4894     SetEnvironmentVariableA("WineMuiTest2", NULL);
4895     SetEnvironmentVariableA("WineMuiExe", NULL);
4896     SetEnvironmentVariableA("WineMuiDat", NULL);
4897 }
4898
4899 static void test_EnumDynamicTimeZoneInformation(void)
4900 {
4901     LSTATUS status;
4902     HKEY key, subkey;
4903     WCHAR name[128];
4904     WCHAR keyname[128];
4905     WCHAR sysdir[MAX_PATH];
4906     DWORD index, ret, gle, size;
4907     DYNAMIC_TIME_ZONE_INFORMATION bogus_dtzi, dtzi;
4908     struct tz_reg_data
4909     {
4910         LONG bias;
4911         LONG std_bias;
4912         LONG dlt_bias;
4913         SYSTEMTIME std_date;
4914         SYSTEMTIME dlt_date;
4915     } tz_data;
4916
4917     if (!pEnumDynamicTimeZoneInformation)
4918     {
4919         win_skip("EnumDynamicTimeZoneInformation is not supported.\n");
4920         return;
4921     }
4922
4923     if (pRegLoadMUIStringW)
4924         GetSystemDirectoryW(sysdir, ARRAY_SIZE(sysdir));
4925
4926     SetLastError(0xdeadbeef);
4927     ret = pEnumDynamicTimeZoneInformation(0, NULL);
4928     gle = GetLastError();
4929     ok(gle == 0xdeadbeef, "got 0x%lx\n", gle);
4930     ok(ret == ERROR_INVALID_PARAMETER, "got %ld\n", ret);
4931
4932     memset(&bogus_dtzi, 0xcc, sizeof(bogus_dtzi));
4933     memset(&dtzi, 0xcc, sizeof(dtzi));
4934     SetLastError(0xdeadbeef);
4935     ret = pEnumDynamicTimeZoneInformation(-1, &dtzi);
4936     gle = GetLastError();
4937     ok(gle == 0xdeadbeef, "got 0x%lx\n", gle);
4938     ok(ret == ERROR_NO_MORE_ITEMS, "got %ld\n", ret);
4939     ok(!memcmp(&dtzi, &bogus_dtzi, sizeof(dtzi)), "mismatch\n");
4940
4941     status = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
4942             "Software\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones", 0,
4943             KEY_ENUMERATE_SUB_KEYS|KEY_QUERY_VALUE, &key);
4944     ok(status == ERROR_SUCCESS, "got %ld\n", status);
4945     index = 0;
4946     while (!(status = RegEnumKeyW(key, index, keyname, ARRAY_SIZE(keyname))))
4947     {
4948         winetest_push_context("%s" , wine_dbgstr_w(keyname));
4949         subkey = NULL;
4950         status = RegOpenKeyExW(key, keyname, 0, KEY_QUERY_VALUE, &subkey);
4951         ok(status == ERROR_SUCCESS, "got %ld\n", status);
4952
4953         memset(&dtzi, 0xcc, sizeof(dtzi));
4954         SetLastError(0xdeadbeef);
4955         ret = pEnumDynamicTimeZoneInformation(index, &dtzi);
4956         gle = GetLastError();
4957         /* recently added time zones may not have MUI strings */
4958         ok(gle == ERROR_SUCCESS ||
4959            gle == ERROR_RESOURCE_TYPE_NOT_FOUND /* Win10 1809 32-bit */ ||
4960            gle == ERROR_MUI_FILE_NOT_FOUND /* Win10 1809 64-bit */,
4961             "got 0x%lx\n", gle);
4962         ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
4963         ok(!lstrcmpW(dtzi.TimeZoneKeyName, keyname), "expected %s, got %s\n",
4964             wine_dbgstr_w(keyname), wine_dbgstr_w(dtzi.TimeZoneKeyName));
4965
4966         if (gle == ERROR_SUCCESS)
4967         {
4968             size = sizeof(name);
4969             memset(name, 0, sizeof(name));
4970             status = pRegGetValueW(subkey, NULL, L"Std", RRF_RT_REG_SZ, NULL, name, &size);
4971             ok(status == ERROR_SUCCESS, "status %ld Std %s\n", status,
4972                wine_dbgstr_w(name));
4973             ok(*name, "Std name is empty\n");
4974             if (pRegLoadMUIStringW)
4975             {
4976                 size = sizeof(name);
4977                 memset(name, 0, sizeof(name));
4978                 status = pRegLoadMUIStringW(subkey, L"MUI_Std", name, size, &size, 0, sysdir);
4979                 ok(status == ERROR_SUCCESS, "status %ld MUI_Std %s\n",
4980                    status, wine_dbgstr_w(name));
4981                 ok(*name, "MUI_Std name is empty\n");
4982             }
4983             ok(!memcmp(&dtzi.StandardName, name, size), "expected %s, got %s\n",
4984                wine_dbgstr_w(name), wine_dbgstr_w(dtzi.StandardName));
4985
4986             size = sizeof(name);
4987             memset(name, 0, sizeof(name));
4988             status = pRegGetValueW(subkey, NULL, L"Dlt", RRF_RT_REG_SZ, NULL, name, &size);
4989             ok(status == ERROR_SUCCESS, "status %ld %s Dlt %s\n",
4990                status, wine_dbgstr_w(keyname), wine_dbgstr_w(name));
4991             ok(*name, "Dlt name is empty\n");
4992             if (pRegLoadMUIStringW)
4993             {
4994                 size = sizeof(name);
4995                 memset(name, 0, sizeof(name));
4996                 status = pRegLoadMUIStringW(subkey, L"MUI_Dlt", name, size, &size, 0, sysdir);
4997                 ok(status == ERROR_SUCCESS, "status %ld %s MUI_Dlt %s\n",
4998                    status, wine_dbgstr_w(keyname), wine_dbgstr_w(name));
4999                 ok(*name, "MUI_Dlt name is empty\n");
5000             }
5001             ok(!memcmp(&dtzi.DaylightName, name, size), "expected %s, got %s\n",
5002                wine_dbgstr_w(name), wine_dbgstr_w(dtzi.DaylightName));
5003
5004             size = sizeof(name);
5005             memset(name, 0, sizeof(name));
5006             status = pRegGetValueW(subkey, NULL, L"Display", RRF_RT_REG_SZ, NULL, name, &size);
5007             ok(status == ERROR_SUCCESS, "status %ld %s Display %s\n",
5008                status, wine_dbgstr_w(keyname), wine_dbgstr_w(name));
5009             ok(*name, "Display name is empty\n");
5010             if (pRegLoadMUIStringW)
5011             {
5012                 size = sizeof(name);
5013                 memset(name, 0, sizeof(name));
5014                 status = pRegLoadMUIStringW(subkey, L"MUI_Display", name, size, &size, 0, sysdir);
5015                 /* recently added time zones may not have MUI strings */
5016                 ok((status == ERROR_SUCCESS && *name) ||
5017                    broken(status == ERROR_RESOURCE_TYPE_NOT_FOUND) /* Win10 1809 32-bit */ ||
5018                    broken(status == ERROR_MUI_FILE_NOT_FOUND) /* Win10 1809 64-bit */,
5019                    "status %ld MUI_Display %s\n", status, wine_dbgstr_w(name));
5020             }
5021         }
5022         else
5023         {
5024             ok(!dtzi.StandardName[0], "expected empty StandardName\n");
5025             ok(!dtzi.DaylightName[0], "expected empty DaylightName\n");
5026         }
5027
5028         ok(!dtzi.DynamicDaylightTimeDisabled, "got %d\n", dtzi.DynamicDaylightTimeDisabled);
5029
5030         size = sizeof(tz_data);
5031         status = pRegGetValueW(key, keyname, L"TZI", RRF_RT_REG_BINARY, NULL, &tz_data, &size);
5032         ok(status == ERROR_SUCCESS, "got %ld\n", status);
5033
5034         ok(dtzi.Bias == tz_data.bias, "expected %ld, got %ld\n",
5035             tz_data.bias, dtzi.Bias);
5036         ok(dtzi.StandardBias == tz_data.std_bias, "expected %ld, got %ld\n",
5037             tz_data.std_bias, dtzi.StandardBias);
5038         ok(dtzi.DaylightBias == tz_data.dlt_bias, "expected %ld, got %ld\n",
5039             tz_data.dlt_bias, dtzi.DaylightBias);
5040
5041         ok(!memcmp(&dtzi.StandardDate, &tz_data.std_date, sizeof(dtzi.StandardDate)),
5042             "expected %s, got %s\n",
5043             dbgstr_SYSTEMTIME(&tz_data.std_date), dbgstr_SYSTEMTIME(&dtzi.StandardDate));
5044
5045         ok(!memcmp(&dtzi.DaylightDate, &tz_data.dlt_date, sizeof(dtzi.DaylightDate)),
5046             "expected %s, got %s\n",
5047             dbgstr_SYSTEMTIME(&tz_data.dlt_date), dbgstr_SYSTEMTIME(&dtzi.DaylightDate));
5048
5049         winetest_pop_context();
5050         RegCloseKey(subkey);
5051         index++;
5052     }
5053     ok(status == ERROR_NO_MORE_ITEMS, "got %ld\n", status);
5054
5055     memset(&dtzi, 0xcc, sizeof(dtzi));
5056     SetLastError(0xdeadbeef);
5057     ret = pEnumDynamicTimeZoneInformation(index, &dtzi);
5058     gle = GetLastError();
5059     ok(gle == 0xdeadbeef, "got 0x%lx\n", gle);
5060     ok(ret == ERROR_NO_MORE_ITEMS, "got %ld\n", ret);
5061     ok(!memcmp(&dtzi, &bogus_dtzi, sizeof(dtzi)), "mismatch\n");
5062
5063     RegCloseKey(key);
5064 }
5065
5066 static void test_RegRenameKey(void)
5067 {
5068     HKEY key, key2;
5069     LSTATUS ret;
5070
5071     ret = RegRenameKey(NULL, NULL, NULL);
5072     ok(ret == ERROR_INVALID_PARAMETER, "Unexpected return value %ld.\n", ret);
5073     ret = RegRenameKey(NULL, NULL, L"newname");
5074     ok(ret == ERROR_INVALID_HANDLE, "Unexpected return value %ld.\n", ret);
5075     ret = RegRenameKey(NULL, L"oldname", NULL);
5076     ok(ret == ERROR_INVALID_HANDLE, "Unexpected return value %ld.\n", ret);
5077     ret = RegRenameKey(NULL, L"oldname", L"newname");
5078     ok(ret == ERROR_INVALID_HANDLE, "Unexpected return value %ld.\n", ret);
5079
5080     ret = RegCreateKeyExA(hkey_main, "TestRenameKey", 0, NULL, 0, KEY_READ, NULL, &key, NULL);
5081     ok(!ret, "Unexpected return value %ld.\n", ret);
5082     ret = RegRenameKey(key, NULL, L"TestNewRenameKey");
5083     ok(ret == ERROR_ACCESS_DENIED, "Unexpected return value %ld.\n", ret);
5084     RegCloseKey(key);
5085
5086     /* Rename itself. */
5087     ret = RegCreateKeyExA(hkey_main, "TestRenameKey", 0, NULL, 0, KEY_WRITE, NULL, &key, NULL);
5088     ok(!ret, "Unexpected return value %ld.\n", ret);
5089     ret = RegRenameKey(key, NULL, NULL);
5090     ok(ret == ERROR_INVALID_PARAMETER, "Unexpected return value %ld.\n", ret);
5091     ret = RegRenameKey(key, NULL, L"TestNewRenameKey");
5092     ok(!ret, "Unexpected return value %ld.\n", ret);
5093     RegCloseKey(key);
5094
5095     ret = RegDeleteKeyA(hkey_main, "TestNewRenameKey");
5096     ok(!ret, "Unexpected return value %ld.\n", ret);
5097     ret = RegDeleteKeyA(hkey_main, "TestRenameKey");
5098     ok(ret, "Unexpected return value %ld.\n", ret);
5099
5100     /* Subkey does not exist. */
5101     ret = RegCreateKeyExA(hkey_main, "TestRenameKey", 0, NULL, 0, KEY_WRITE, NULL, &key, NULL);
5102     ok(!ret, "Unexpected return value %ld.\n", ret);
5103     ret = RegRenameKey(key, L"unknown_subkey", NULL);
5104     ok(ret == ERROR_FILE_NOT_FOUND, "Unexpected return value %ld.\n", ret);
5105     ret = RegRenameKey(key, L"unknown_subkey", L"known_subkey");
5106     ok(ret == ERROR_FILE_NOT_FOUND, "Unexpected return value %ld.\n", ret);
5107
5108     /* Rename existing subkey. */
5109     ret = RegCreateKeyExA(key, "known_subkey", 0, NULL, 0, KEY_WRITE, NULL, &key2, NULL);
5110     ok(!ret, "Unexpected return value %ld.\n", ret);
5111     RegCloseKey(key2);
5112
5113     ret = RegRenameKey(key, L"known_subkey", L"renamed_subkey");
5114     ok(!ret, "Unexpected return value %ld.\n", ret);
5115
5116     ret = RegDeleteKeyA(key, "renamed_subkey");
5117     ok(!ret, "Unexpected return value %ld.\n", ret);
5118     ret = RegDeleteKeyA(key, "known_subkey");
5119     ok(ret, "Unexpected return value %ld.\n", ret);
5120
5121     RegCloseKey(key);
5122 }
5123
5124 START_TEST(registry)
5125 {
5126     /* Load pointers for functions that are not available in all Windows versions */
5127     InitFunctionPtrs();
5128
5129     setup_main_key();
5130     check_user_privs();
5131     test_set_value();
5132     create_test_entries();
5133     test_enum_value();
5134     test_query_value_ex();
5135     test_get_value();
5136     test_reg_open_key();
5137     test_reg_create_key();
5138     test_reg_close_key();
5139     test_reg_delete_key();
5140     test_reg_query_value();
5141     test_reg_query_info();
5142     test_string_termination();
5143     test_multistring_termination();
5144     test_symlinks();
5145     test_redirection();
5146     test_classesroot();
5147     test_classesroot_enum();
5148     test_classesroot_mask();
5149     test_reg_load_key();
5150     test_reg_load_app_key();
5151     test_reg_copy_tree();
5152     test_reg_delete_tree();
5153     test_rw_order();
5154     test_deleted_key();
5155     test_delete_value();
5156     test_delete_key_value();
5157     test_RegOpenCurrentUser();
5158     test_RegNotifyChangeKeyValue();
5159     test_performance_keys();
5160     test_RegLoadMUIString();
5161     test_EnumDynamicTimeZoneInformation();
5162     test_perflib_key();
5163     test_RegRenameKey();
5164
5165     /* cleanup */
5166     delete_key( hkey_main );
5167
5168     test_regconnectregistry();
5169 }