rostests/apitests/advapi32/RegQueryValueExW.c

   1 /*
   2  * PROJECT:         ReactOS api tests
   3  * LICENSE:         GPLv2+ - See COPYING in the top level directory
   4  * PURPOSE:         Test for the RegQueryValueW API
   5  * PROGRAMMER:      Victor Martinez Calvo <victor.martinez@reactos.org>
   6  */
   7 #include <apitest.h>
   8
   9 #define WIN32_NO_STATUS
  10 #include <winreg.h>
  11
  12 static DWORD delete_key(HKEY hkey)
  13 {
  14     WCHAR name[MAX_PATH];
  15     DWORD ret;
  16
  17     while (!(ret = RegEnumKeyW(hkey, 0, name, _countof(name))))
  18     {
  19         HKEY tmp;
  20         if (!(ret = RegOpenKeyExW(hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp)))
  21         {
  22             ret = delete_key(tmp);
  23         }
  24         if (ret)
  25             break;
  26     }
  27     if (ret == ERROR_NO_MORE_ITEMS)
  28     {
  29         RegDeleteKeyW(hkey, L"");
  30         ret = 0;
  31     }
  32     RegCloseKey(hkey);
  33     return ret;
  34 }
  35
  36 START_TEST(RegQueryValueExW)
  37 {
  38     HKEY hkey_main;
  39     HKEY subkey;
  40     DWORD type, size, ret, reserved;
  41     const WCHAR string1W[] = L"1";
  42     const WCHAR string22W[] = L"Thisstringhas22letters";
  43     WCHAR data22[22];
  44     WCHAR data23[23];
  45     WCHAR data24[24];
  46
  47
  48     /* If the tree key already exist, delete it to ensure proper testing*/
  49     if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\advapi32_apitest", 0, KEY_ALL_ACCESS, &hkey_main) == ERROR_SUCCESS)
  50         delete_key(hkey_main);
  51
  52     /* Ready to recreate it */
  53     SetLastError(0xdeadbeef);
  54     ret = RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\advapi32_apitest", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey_main, NULL);
  55     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %lu\n", ret);
  56     ok(GetLastError(), "RegCreateKeyExW failed: %lx\n", GetLastError());
  57     if(ret != ERROR_SUCCESS)
  58     {
  59         trace("Unable to create test key, aborting!\n");
  60         return;
  61     }
  62
  63     SetLastError(0xdeadbeef);
  64     ret = RegCreateKeyExW(hkey_main, L"subkey", 0, L"subkey class", 0, KEY_ALL_ACCESS, NULL, &subkey, NULL);
  65     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %lu\n", ret);
  66     ok(GetLastError(), "RegCreateKeyExW failed: %lx\n", GetLastError());
  67
  68     /* All NULL */
  69     SetLastError(0xdeadbeef);
  70     ret = RegQueryValueExW(NULL, NULL, NULL, NULL, NULL, NULL);
  71     ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
  72     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
  73
  74     /* All NULL. Reserved not NULL */
  75     type = 666;
  76     size = 666;
  77     reserved = 3;
  78     SetLastError(0xdeadbeef);
  79     ret = RegQueryValueExW(NULL, NULL, &reserved, NULL, NULL, NULL);
  80     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
  81     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
  82     ok(reserved == 3, "Expected reserved=3, reserved is: %ld \n", reserved);
  83
  84     /* NULL handle. NULL value. Reserved not NULL */
  85     type = 666;
  86     size = 666;
  87     reserved = 3;
  88     SetLastError(0xdeadbeef);
  89     ret = RegQueryValueExW(NULL, NULL, &reserved, &type, NULL, &size);
  90     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
  91     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
  92     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
  93     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
  94     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld \n", reserved);
  95
  96     /* NULL handle. NULL value */
  97     type = 666;
  98     size = 666;
  99     SetLastError(0xdeadbeef);
 100     ret = RegQueryValueExW(NULL, NULL, NULL, &type, NULL, &size);
 101     ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
 102     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 103     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 104     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 105
 106     /* NULL handle . Inexistent value. Reserved not NULL */
 107     type = 666;
 108     size = 666;
 109     reserved = 3;
 110     SetLastError(0xdeadbeef);
 111     ret = RegQueryValueExW(NULL, L"MSITESTVAR11", &reserved, &type, NULL, &size);
 112     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
 113     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 114     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 115     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 116     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld \n", reserved);
 117
 118     /* NULL handle . Inexistent value. */
 119     type = 666;
 120     size = 666;
 121     SetLastError(0xdeadbeef);
 122     ret = RegQueryValueExW(NULL, L"MSITESTVAR11", NULL, &type, NULL, &size);
 123     ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
 124     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 125     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 126     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 127
 128     /* NULL handle */
 129     type = 666;
 130     size = 666;
 131     SetLastError(0xdeadbeef);
 132     ret = RegQueryValueExW(NULL, L"MSITESTVAR11", NULL, &type, NULL, &size);
 133     ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
 134     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 135     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 136     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 137
 138     /* INVALID handle. NULL value. Reserved not NULL */
 139     type = 666;
 140     size = 666;
 141     reserved = 3;
 142     SetLastError(0xdeadbeef);
 143     ret = RegQueryValueExW((HKEY)-4, NULL, &reserved, &type, NULL, &size);
 144     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
 145     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 146     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 147     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 148     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld \n", reserved);
 149
 150     /* INVALID handle. NULL value.*/
 151     type = 666;
 152     size = 666;
 153     SetLastError(0xdeadbeef);
 154     ret = RegQueryValueExW((HKEY)-4, NULL, NULL, &type, NULL, &size);
 155     ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
 156     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 157     ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
 158     ok(size == 0, "Expected size = 0, size is: %ld\n", size);
 159     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld \n", reserved);
 160
 161     /* INVALID handle. Non-existent value. Reserved not NULL*/
 162     type = 666;
 163     size = 666;
 164     reserved = 3;
 165     SetLastError(0xdeadbeef);
 166     ret = RegQueryValueExW((HKEY)-4, L"MSITESTVAR11", &reserved, &type, NULL, &size);
 167     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
 168     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 169     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 170     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 171     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld \n", reserved);
 172
 173     /* INVALID handle. Non-existent value. */
 174     type = 666;
 175     size = 666;
 176     SetLastError(0xdeadbeef);
 177     ret = RegQueryValueExW((HKEY)-4, L"MSITESTVAR11", NULL, &type, NULL, &size);
 178     ok(ret == ERROR_INVALID_HANDLE, "RegQueryValueExW returned: %lx\n", ret);
 179     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 180     ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
 181     ok(size == 0, "Expected size = 0, size is: %ld\n", size);
 182
 183     /* VALID handle, Non-existent value, Reserved not NULL */
 184     type = 666;
 185     size = 666;
 186     reserved = 3;
 187     SetLastError(0xdeadbeef);
 188     ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", &reserved, &type, NULL, &size);
 189     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
 190     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 191     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 192     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 193     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld\n", reserved);
 194
 195     /* VALID handle, Non-existent value */
 196     type = 666;
 197     size = 666;
 198     SetLastError(0xdeadbeef);
 199     ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", NULL, &type, NULL, &size);
 200     ok(ret == ERROR_FILE_NOT_FOUND, "RegQueryValueExW returned: %lx\n", ret);
 201     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 202     ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
 203     ok(size == 0, "Expected size = 0, size is: %ld\n", size);
 204
 205     /* VALID handle, NULL value */
 206     type = 666;
 207     size = 666;
 208     SetLastError(0xdeadbeef);
 209     ret = RegQueryValueExW(hkey_main, NULL, NULL, &type, NULL, &size);
 210     ok(ret == ERROR_FILE_NOT_FOUND, "RegQueryValueExW returned: %lx\n", ret);
 211     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 212     ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
 213     ok(size == 0, "Expected size = 0, size is: %ld\n", size);
 214
 215     /* Create the value */
 216     SetLastError(0xdeadbeef);
 217     if ((ret = RegSetValueExW(hkey_main, L"MSITESTVAR11", 0, REG_NONE, (const BYTE *)string1W, 4)) != ERROR_SUCCESS)
 218     {
 219         ok(1, "RegSetValueExW failed: %lx, %lx\n", ret, GetLastError());
 220     }
 221     if ((ret = RegSetValueExW(hkey_main, L"LONGSTRING", 0, REG_SZ, (const BYTE *)string22W, (wcslen(string22W)+1) * sizeof(WCHAR))) != ERROR_SUCCESS)
 222     {
 223         ok(1, "RegSetValueExW failed: %lx, %lx\n", ret, GetLastError());
 224     }
 225
 226     /* Existent value. Reserved not NULL */
 227     SetLastError(0xdeadbeef);
 228     size = 666;
 229     type = 666;
 230     reserved = 3;
 231     ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", &reserved, &type, NULL, &size);
 232     ok(ret == ERROR_INVALID_PARAMETER, "RegQueryValueExW returned: %lx\n", ret);
 233     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 234     ok(type == 666, "Expected untouched, Type was set with: %ld\n", type);
 235     ok(size == 666, "Expected untouched, Size was set with: %ld \n", size);
 236     ok(reserved == 3, "Expected reserved = 3, reserved is: %ld \n", reserved);
 237
 238     /* Existent value */
 239     SetLastError(0xdeadbeef);
 240     size = 666;
 241     type = 666;
 242     ret = RegQueryValueExW(hkey_main, L"MSITESTVAR11", NULL, &type, NULL, &size);
 243     ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
 244     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 245     ok(type == REG_NONE, "Expected REG_NONE, Type is: %ld\n", type);
 246     ok(size == 4, "Expected size = 4, size is: %ld\n", size);
 247
 248     /* Data tests */
 249     /* Buffer one wchar smaller than needed */
 250     SetLastError(0xdeadbeef);
 251     size = sizeof(data22);
 252     type = 666;
 253     ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data22, &size);
 254     ok(ret == ERROR_MORE_DATA, "RegQueryValueExW returned: %lx\n", ret);
 255     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 256     ok(type == REG_SZ, "Expected REG_NONE, Type is: %ld\n", type);
 257     ok(size == 46, "Expected size = 46, size is: %ld\n", size);
 258     ok(wcscmp(data22, string22W), "Expected being different!");
 259
 260     /* Buffer has perfect size */
 261     SetLastError(0xdeadbeef);
 262     size = sizeof(data23);
 263     type = 666;
 264     ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data23, &size);
 265     ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
 266     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 267     ok(type == REG_SZ, "Expected REG_NONE, Type is: %ld\n", type);
 268     ok(size == 46, "Expected size = 46, size is: %ld", size);
 269     ok(!wcscmp(data23,string22W), "Expected same string! data23: %S, string22W: %S", data23, string22W);
 270
 271     /* Buffer one wchar bigger than needed */
 272     SetLastError(0xdeadbeef);
 273     size = sizeof(data24);
 274     type = 666;
 275     ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data24, &size);
 276     ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
 277     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 278     ok(type == REG_SZ, "Expected REG_NONE, Type is: %ld\n", type);
 279     ok(size == 46, "Expected size = 46, size is: %ld\n", size);
 280     ok(!wcscmp(data24, string22W), "Expected same string! data24: %S, string22W: %S\n", data24, string22W);
 281
 282     /* Buffer has perfect size. Size wrong: 1 WCHAR less */
 283     SetLastError(0xdeadbeef);
 284     memset(data23, 0, sizeof(data23));
 285     size = sizeof(data23) - 2;
 286     type = 666;
 287     ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data23, &size);
 288     ok(ret == ERROR_MORE_DATA, "RegQueryValueExW returned: %lx\n", ret);
 289     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 290     ok(type == REG_SZ, "Expected REG_NONE, Type is: %ld\n", type);
 291     ok(size == 46, "Expected size = 46, size is: %ld", size);
 292     ok(wcscmp(data23, string22W), "Expected different string!\n");
 293
 294     /* Buffer has perfect size. Size wrong: 1 WCHAR more */
 295     SetLastError(0xdeadbeef);
 296     memset(data23, 0, sizeof(data23));
 297     size = sizeof(data23) + 2;
 298     type = 666;
 299     ret = RegQueryValueExW(hkey_main, L"LONGSTRING", NULL, &type, (LPBYTE)data23, &size);
 300     ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned: %lx\n", ret);
 301     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 302     ok(type == REG_SZ, "Expected REG_NONE, Type is: %ld\n", type);
 303     ok(size == 46, "Expected size = 46, size is: %ld", size);
 304     ok(!wcscmp(data23, string22W), "Expected same string! data23: %S, string22W: %S", data23, string22W);
 305
 306     /* Ask for a var that doesnt exist. */
 307     SetLastError(0xdeadbeef);
 308     size = sizeof(data23);
 309     memset(data23, 0, sizeof(data23));
 310     type = 666;
 311     ret = RegQueryValueExW(hkey_main, L"XXXXXYYYYYZZZZZZ", NULL, &type, (LPBYTE)data23, &size);
 312     ok(ret == ERROR_FILE_NOT_FOUND, "RegQueryValueExW returned: %lx\n", ret);
 313     ok(GetLastError() == 0xdeadbeef, "RegQueryValueExW returned: %lx\n", GetLastError());
 314     /* 2k3 leaves garbage */
 315     ok(type == REG_NONE || broken(type != REG_NONE && type != 666), "Expected REG_NONE, Type is: %ld\n", type);
 316     ok(size == 46, "Expected size = 46, size is: %ld", size);
 317     ok(!wcscmp(data23,L""), "Expected same string! data23: %S, ''", data23);
 318
 319
 320     RegCloseKey(hkey_main);
 321     RegCloseKey(subkey);
 322
 323     /* Delete the whole test key */
 324     RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\ReactOS\\advapi32_apitest", &hkey_main);
 325     delete_key(hkey_main);
 326 }