programs/reg/tests/query.c

   1 /*
   2  * Copyright 2014 Akihiro Sagawa
   3  * Copyright 2016-2018, 2021 Hugh McMaster
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "reg_test.h"
  21
  22 static void read_from_pipe(HANDLE child_proc_stdout, BYTE *buf, DWORD buf_size)
  23 {
  24     DWORD read, len = 0;
  25     BOOL ret;
  26
  27     while (1)
  28     {
  29         ret = ReadFile(child_proc_stdout, buf + len, buf_size - len, &read, NULL);
  30         if (!ret || !read) break;
  31
  32         len += read;
  33     }
  34
  35     buf[len] = 0;
  36 }
  37
  38 #define read_reg_output(c,b,s,r) read_reg_output_(__FILE__,__LINE__,c,b,s,r)
  39 static BOOL read_reg_output_(const char *file, unsigned line, const char *cmd,
  40                              BYTE *buf, DWORD buf_size, DWORD *rc)
  41 {
  42     SECURITY_ATTRIBUTES sa;
  43     HANDLE pipe_stdout_rd, pipe_stdout_wr;
  44     STARTUPINFOA si = {0};
  45     PROCESS_INFORMATION pi;
  46     char cmdline[256];
  47     BOOL bret;
  48     DWORD ret;
  49
  50     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  51     sa.bInheritHandle = TRUE;
  52     sa.lpSecurityDescriptor = NULL;
  53
  54     if (!CreatePipe(&pipe_stdout_rd, &pipe_stdout_wr, &sa, 0))
  55         return FALSE;
  56
  57     if (!SetHandleInformation(pipe_stdout_rd, HANDLE_FLAG_INHERIT, 0))
  58         return FALSE;
  59
  60     si.cb = sizeof(si);
  61     si.dwFlags = STARTF_USESTDHANDLES;
  62     si.hStdInput = INVALID_HANDLE_VALUE;
  63     si.hStdOutput = pipe_stdout_wr;
  64     si.hStdError = INVALID_HANDLE_VALUE;
  65
  66     strcpy(cmdline, cmd);
  67     if (!CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
  68         return FALSE;
  69
  70     CloseHandle(pipe_stdout_wr);
  71
  72     read_from_pipe(pipe_stdout_rd, buf, buf_size);
  73
  74     ret = WaitForSingleObject(pi.hProcess, 10000);
  75     if (ret == WAIT_TIMEOUT)
  76         TerminateProcess(pi.hProcess, 1);
  77
  78     bret = GetExitCodeProcess(pi.hProcess, rc);
  79     lok(bret, "GetExitCodeProcess failed: %ld\n", GetLastError());
  80
  81     CloseHandle(pipe_stdout_rd);
  82     CloseHandle(pi.hThread);
  83     CloseHandle(pi.hProcess);
  84     return bret;
  85 }
  86
  87 #define compare_query(b,e,c,todo) compare_query_(__FILE__,__LINE__,b,e,c,todo)
  88 static void compare_query_(const char *file, unsigned line, const BYTE *buf,
  89                            const char *expected, BOOL cmp_len, DWORD todo)
  90 {
  91     const char *str = (const char *)buf;
  92     const char *err = "query output does not match expected output";
  93
  94     if (!cmp_len)
  95     {
  96         todo_wine_if (todo & TODO_REG_COMPARE)
  97             lok(!strcmp(str, expected), "%s\n", err);
  98     }
  99     else
 100     {
 101         todo_wine_if (todo & TODO_REG_COMPARE)
 102             lok(!strncmp(str, expected, strlen(expected)), "%s\n", err);
 103     }
 104 }
 105
 106 /* Unit tests */
 107
 108 static void test_command_syntax(void)
 109 {
 110     DWORD r;
 111
 112     run_reg_exe("reg query", &r);
 113     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 114
 115     run_reg_exe("reg query /?", &r);
 116     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 117
 118     run_reg_exe("reg query /h", &r);
 119     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 120
 121     run_reg_exe("reg query -H", &r);
 122     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 123
 124     run_reg_exe("reg query HKCU\\" KEY_BASE " /v", &r);
 125     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 126
 127     run_reg_exe("reg query HKCU\\" KEY_BASE " /v Test1 /v Test2", &r);
 128     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 129
 130     run_reg_exe("reg query HKCU\\" KEY_BASE " /v Test1 /ve", &r);
 131     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 132
 133     run_reg_exe("reg query HKCU\\" KEY_BASE " /s /s", &r);
 134     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 135
 136     /* Test registry view */
 137     run_reg_exe("reg query HKCU\\" KEY_BASE " /reg:32 /reg:32", &r);
 138     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 139
 140     run_reg_exe("reg query HKCU\\" KEY_BASE " /reg:32 /reg:64", &r);
 141     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 142
 143     run_reg_exe("reg query HKCU\\" KEY_BASE " /reg:64 /reg:64", &r);
 144     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 145 }
 146
 147 static void test_query(void)
 148 {
 149     const char *test1 = "\r\n"
 150         "HKEY_CURRENT_USER\\" KEY_BASE "\r\n"
 151         "    Test1    REG_SZ    Hello, World\r\n"
 152         "    Test2    REG_DWORD    0x123\r\n\r\n";
 153
 154     const char *test2 = "\r\n"
 155         "HKEY_CURRENT_USER\\" KEY_BASE "\r\n"
 156         "    Test1    REG_SZ    Hello, World\r\n\r\n";
 157
 158     const char *test3 = "\r\n"
 159         "HKEY_CURRENT_USER\\" KEY_BASE "\r\n"
 160         "    Test1    REG_SZ    Hello, World\r\n"
 161         "    Test2    REG_DWORD    0x123\r\n"
 162         "    Wine    REG_SZ    First instance\r\n\r\n"
 163         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey\r\n";
 164
 165     const char *test4 = "\r\n"
 166         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey\r\n"
 167         "    Test3    REG_SZ    Some string data\r\n"
 168         "    Test4    REG_DWORD    0xabc\r\n\r\n";
 169
 170     const char *test5 = "\r\n"
 171         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey\r\n"
 172         "    Test4    REG_DWORD    0xabc\r\n\r\n";
 173
 174     const char *test6 = "\r\n"
 175         "HKEY_CURRENT_USER\\" KEY_BASE "\r\n"
 176         "    Test1    REG_SZ    Hello, World\r\n"
 177         "    Test2    REG_DWORD    0x123\r\n"
 178         "    Wine    REG_SZ    First instance\r\n\r\n"
 179         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey\r\n"
 180         "    Test3    REG_SZ    Some string data\r\n"
 181         "    Test4    REG_DWORD    0xabc\r\n"
 182         "    Wine    REG_SZ    Second instance\r\n\r\n";
 183
 184     const char *test7 = "\r\n"
 185         "HKEY_CURRENT_USER\\" KEY_BASE "\r\n"
 186         "    Wine    REG_SZ    First instance\r\n\r\n"
 187         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey\r\n"
 188         "    Wine    REG_SZ    Second instance\r\n\r\n";
 189
 190     const char *test8a = "\r\n"
 191         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey1\r\n"
 192         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey2\r\n"
 193         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey3\r\n"
 194         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey4\r\n";
 195
 196     const char *test8b = "\r\n"
 197         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey1\r\n\r\n"
 198         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey2\r\n\r\n"
 199         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey3\r\n\r\n"
 200         "HKEY_CURRENT_USER\\" KEY_BASE "\\subkey4\r\n\r\n";
 201
 202     DWORD r, dword = 0x123;
 203     HKEY hkey, subkey;
 204     BYTE buf[512];
 205
 206     delete_tree(HKEY_CURRENT_USER, KEY_BASE, 0);
 207
 208     /* Key not present */
 209     run_reg_exe("reg query HKCU\\" KEY_BASE, &r);
 210     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 211
 212     /* Create a test key */
 213     add_key(HKEY_CURRENT_USER, KEY_BASE, 0, &hkey);
 214     add_value(hkey, "Test1", REG_SZ, "Hello, World", 13);
 215     add_value(hkey, "Test2", REG_DWORD, &dword, sizeof(dword));
 216
 217     run_reg_exe("reg query HKCU\\" KEY_BASE " /v Missing", &r);
 218     ok(r == REG_EXIT_FAILURE, "got exit code %ld, expected 1\n", r);
 219
 220     read_reg_output("reg query HKCU\\" KEY_BASE, buf, sizeof(buf), &r);
 221     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 222     compare_query(buf, test1, FALSE, 0);
 223
 224     run_reg_exe("reg query HKCU\\" KEY_BASE " /ve", &r);
 225     ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
 226        "got exit code %ld, expected 0\n", r);
 227
 228     read_reg_output("reg query HKCU\\" KEY_BASE " /v Test1", buf, sizeof(buf), &r);
 229     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 230     compare_query(buf, test2, FALSE, 0);
 231
 232     run_reg_exe("reg query HKCU\\" KEY_BASE " /v Test2", &r);
 233     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 234
 235     add_value(hkey, "Wine", REG_SZ, "First instance", 15);
 236
 237     /* Create a test subkey */
 238     add_key(hkey, "subkey", 0, &subkey);
 239
 240     read_reg_output("reg query HKCU\\" KEY_BASE, buf, sizeof(buf), &r);
 241     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 242     compare_query(buf, test3, FALSE, 0);
 243
 244     add_value(subkey, "Test3", REG_SZ, "Some string data", 16);
 245     dword = 0xabc;
 246     add_value(subkey, "Test4", REG_DWORD, &dword, sizeof(dword));
 247
 248     read_reg_output("reg query HKCU\\" KEY_BASE "\\subkey", buf, sizeof(buf), &r);
 249     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 250     compare_query(buf, test4, FALSE, 0);
 251
 252     run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey /v Test3", &r);
 253     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 254
 255     read_reg_output("reg query HKCU\\" KEY_BASE "\\subkey /v Test4", buf, sizeof(buf), &r);
 256     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 257     compare_query(buf, test5, FALSE, 0);
 258
 259     add_value(subkey, "Wine", REG_SZ, "Second instance", 16);
 260
 261     /* Test recursion */
 262     read_reg_output("reg query HKCU\\" KEY_BASE " /s", buf, sizeof(buf), &r);
 263     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 264     compare_query(buf, test6, FALSE, 0);
 265
 266     read_reg_output("reg query HKCU\\" KEY_BASE "\\ /s", buf, sizeof(buf), &r);
 267     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 268     compare_query(buf, test6, FALSE, 0);
 269
 270     read_reg_output("reg query HKCU\\" KEY_BASE " /v Wine /s", buf, sizeof(buf), &r);
 271     ok(r == REG_EXIT_SUCCESS || r == REG_EXIT_FAILURE /* WinXP */,
 272        "got exit code %ld, expected 0\n", r);
 273     compare_query(buf, test7, TRUE, 0);
 274
 275     add_value(hkey, NULL, REG_SZ, "Empty", 6);
 276     add_value(subkey, NULL, REG_SZ, "Empty", 6);
 277     close_key(subkey);
 278     close_key(hkey);
 279
 280     run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey /ve", &r);
 281     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 282
 283     run_reg_exe("reg query HKCU\\" KEY_BASE " /ve /s", &r);
 284     ok(r == REG_EXIT_SUCCESS || r == REG_EXIT_FAILURE /* WinXP */,
 285        "got exit code %ld, expected 0\n", r);
 286
 287     delete_tree(HKEY_CURRENT_USER, KEY_BASE, 0);
 288
 289     /* Subkeys only */
 290     add_key(HKEY_CURRENT_USER, KEY_BASE, 0, &hkey);
 291     add_key(hkey, "subkey1", 0, NULL);
 292     add_key(hkey, "subkey2", 0, NULL);
 293     add_key(hkey, "subkey3", 0, NULL);
 294     add_key(hkey, "subkey4", 0, NULL);
 295     close_key(hkey);
 296
 297     read_reg_output("reg query HKCU\\" KEY_BASE, buf, sizeof(buf), &r);
 298     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 299     compare_query(buf, test8a, FALSE, 0);
 300
 301     read_reg_output("reg query HKCU\\" KEY_BASE " /s", buf, sizeof(buf), &r);
 302     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 303     compare_query(buf, test8b, FALSE, 0);
 304
 305     delete_tree(HKEY_CURRENT_USER, KEY_BASE, 0);
 306 }
 307
 308 static const char *test9a = "\r\n"
 309     "HKEY_LOCAL_MACHINE\\" KEY_BASE "\r\n"
 310     "    Test1    REG_SZ    Hello, World\r\n"
 311     "    Test2    REG_DWORD    0x123\r\n"
 312     "    Wine    REG_SZ    First instance\r\n\r\n"
 313     "HKEY_LOCAL_MACHINE\\" KEY_BASE "\\subkey\r\n";
 314
 315 static const char *test9b = "\r\n"
 316     "HKEY_LOCAL_MACHINE\\" KEY_BASE "\r\n"
 317     "    Test1    REG_SZ    Hello, World\r\n"
 318     "    Test2    REG_DWORD    0x123\r\n"
 319     "    Wine    REG_SZ    First instance\r\n\r\n"
 320     "HKEY_LOCAL_MACHINE\\" KEY_BASE "\\subkey\r\n"
 321     "    Test3    REG_SZ    Some string data\r\n"
 322     "    Test4    REG_DWORD    0xabc\r\n"
 323     "    Wine    REG_SZ    Second instance\r\n\r\n";
 324
 325 static const char *test9c = "\r\n"
 326     "HKEY_LOCAL_MACHINE\\" KEY_BASE "\r\n"
 327     "    Wine    REG_SZ    First instance\r\n\r\n"
 328     "HKEY_LOCAL_MACHINE\\" KEY_BASE "\\subkey\r\n"
 329     "    Wine    REG_SZ    Second instance\r\n\r\n";
 330
 331 static void create_test_key(REGSAM sam)
 332 {
 333     HKEY hkey, subkey;
 334     DWORD dword;
 335
 336     add_key(HKEY_LOCAL_MACHINE, KEY_BASE, sam, &hkey);
 337     add_value(hkey, "Test1", REG_SZ, "Hello, World", 13);
 338     dword = 0x123;
 339     add_value(hkey, "Test2", REG_DWORD, &dword, sizeof(dword));
 340     add_value(hkey, "Wine", REG_SZ, "First instance", 15);
 341
 342     add_key(hkey, "subkey", sam, &subkey);
 343     add_value(subkey, "Test3", REG_SZ, "Some string data", 16);
 344     dword = 0xabc;
 345     add_value(subkey, "Test4", REG_DWORD, &dword, sizeof(dword));
 346     add_value(subkey, "Wine", REG_SZ, "Second instance", 16);
 347
 348     close_key(subkey);
 349     close_key(hkey);
 350 }
 351
 352 static void test_registry_view_win32(void)
 353 {
 354     BOOL is_wow64, is_win32;
 355     DWORD r;
 356     BYTE buf[512];
 357
 358     IsWow64Process(GetCurrentProcess(), &is_wow64);
 359     is_win32 = !is_wow64 && (sizeof(void *) == sizeof(int));
 360
 361     if (!is_win32) return;
 362
 363     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_32KEY);
 364
 365     /* Try querying the 32-bit registry view (32-bit Windows) */
 366     create_test_key(KEY_WOW64_32KEY);
 367
 368     read_reg_output("reg query HKLM\\" KEY_BASE " /reg:32", buf, sizeof(buf), &r);
 369     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 370     compare_query(buf, test9a, FALSE, 0);
 371
 372     read_reg_output("reg query HKLM\\" KEY_BASE " /s /reg:32", buf, sizeof(buf), &r);
 373     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 374     compare_query(buf, test9b, FALSE, 0);
 375
 376     read_reg_output("reg query HKLM\\" KEY_BASE " /v Wine /s /reg:32", buf, sizeof(buf), &r);
 377     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 378     compare_query(buf, test9c, TRUE, 0);
 379
 380     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_32KEY);
 381
 382     /* Try querying the 64-bit registry view, which doesn't exist on 32-bit Windows */
 383     create_test_key(KEY_WOW64_64KEY);
 384
 385     read_reg_output("reg query HKLM\\" KEY_BASE " /reg:64", buf, sizeof(buf), &r);
 386     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 387     compare_query(buf, test9a, FALSE, 0);
 388
 389     read_reg_output("reg query HKLM\\" KEY_BASE " /s /reg:64", buf, sizeof(buf), &r);
 390     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 391     compare_query(buf, test9b, FALSE, 0);
 392
 393     read_reg_output("reg query HKLM\\" KEY_BASE " /v Wine /s /reg:64", buf, sizeof(buf), &r);
 394     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 395     compare_query(buf, test9c, TRUE, 0);
 396
 397     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_64KEY);
 398 }
 399
 400 static void test_registry_view_win64(void)
 401 {
 402     BOOL is_wow64, is_win64;
 403     DWORD r;
 404     BYTE buf[512];
 405
 406     IsWow64Process(GetCurrentProcess(), &is_wow64);
 407     is_win64 = !is_wow64 && (sizeof(void *) > sizeof(int));
 408
 409     if (!is_win64) return;
 410
 411     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_32KEY);
 412
 413     /* Try querying the 32-bit registry view (64-bit Windows) */
 414     create_test_key(KEY_WOW64_32KEY);
 415
 416     read_reg_output("reg query HKLM\\" KEY_BASE " /reg:32", buf, sizeof(buf), &r);
 417     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 418     compare_query(buf, test9a, FALSE, 0);
 419
 420     read_reg_output("reg query HKLM\\" KEY_BASE " /s /reg:32", buf, sizeof(buf), &r);
 421     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 422     compare_query(buf, test9b, FALSE, 0);
 423
 424     read_reg_output("reg query HKLM\\" KEY_BASE " /v Wine /s /reg:32", buf, sizeof(buf), &r);
 425     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 426     compare_query(buf, test9c, TRUE, 0);
 427
 428     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_32KEY);
 429     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_64KEY);
 430
 431     /* Try querying the 64-bit registry view (64-bit Windows) */
 432     create_test_key(KEY_WOW64_64KEY);
 433
 434     read_reg_output("reg query HKLM\\" KEY_BASE " /reg:64", buf, sizeof(buf), &r);
 435     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 436     compare_query(buf, test9a, FALSE, 0);
 437
 438     read_reg_output("reg query HKLM\\" KEY_BASE " /s /reg:64", buf, sizeof(buf), &r);
 439     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 440     compare_query(buf, test9b, FALSE, 0);
 441
 442     read_reg_output("reg query HKLM\\" KEY_BASE " /v Wine /s /reg:64", buf, sizeof(buf), &r);
 443     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 444     compare_query(buf, test9c, TRUE, 0);
 445
 446     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_64KEY);
 447 }
 448
 449 static void test_registry_view_wow64(void)
 450 {
 451     BOOL is_wow64;
 452     DWORD r;
 453     BYTE buf[512];
 454
 455     IsWow64Process(GetCurrentProcess(), &is_wow64);
 456
 457     if (!is_wow64) return;
 458
 459     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_32KEY);
 460
 461     /* Try querying the 32-bit registry view (WOW64) */
 462     create_test_key(KEY_WOW64_32KEY);
 463
 464     read_reg_output("reg query HKLM\\" KEY_BASE " /reg:32", buf, sizeof(buf), &r);
 465     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 466     compare_query(buf, test9a, FALSE, 0);
 467
 468     read_reg_output("reg query HKLM\\" KEY_BASE " /s /reg:32", buf, sizeof(buf), &r);
 469     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 470     compare_query(buf, test9b, FALSE, 0);
 471
 472     read_reg_output("reg query HKLM\\" KEY_BASE " /v Wine /s /reg:32", buf, sizeof(buf), &r);
 473     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 474     compare_query(buf, test9c, TRUE, 0);
 475
 476     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_32KEY);
 477     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_64KEY);
 478
 479     /* Try querying the 64-bit registry view (WOW64) */
 480     create_test_key(KEY_WOW64_64KEY);
 481
 482     read_reg_output("reg query HKLM\\" KEY_BASE " /reg:64", buf, sizeof(buf), &r);
 483     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 484     compare_query(buf, test9a, FALSE, 0);
 485
 486     read_reg_output("reg query HKLM\\" KEY_BASE " /s /reg:64", buf, sizeof(buf), &r);
 487     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 488     compare_query(buf, test9b, FALSE, 0);
 489
 490     read_reg_output("reg query HKLM\\" KEY_BASE " /v Wine /s /reg:64", buf, sizeof(buf), &r);
 491     ok(r == REG_EXIT_SUCCESS, "got exit code %ld, expected 0\n", r);
 492     compare_query(buf, test9c, TRUE, 0);
 493
 494     delete_tree(HKEY_LOCAL_MACHINE, KEY_BASE, KEY_WOW64_64KEY);
 495 }
 496
 497 START_TEST(query)
 498 {
 499     DWORD r;
 500
 501     if (!run_reg_exe("reg.exe /?", &r)) {
 502         win_skip("reg.exe not available, skipping 'query' tests\n");
 503         return;
 504     }
 505
 506     test_command_syntax();
 507     test_query();
 508
 509     /* Check if reg.exe is running with elevated privileges */
 510     if (!is_elevated_process())
 511     {
 512         win_skip("reg.exe is not running with elevated privileges; "
 513                  "skipping registry view tests\n");
 514         return;
 515     }
 516
 517     test_registry_view_win32();
 518     test_registry_view_win64();
 519     test_registry_view_wow64();
 520 }