rostests/winetests/wshom/wshom.c

   1 /*
   2  * Copyright 2011 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define WIN32_NO_STATUS
  20 #define _INC_WINDOWS
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <windef.h>
  25 #include <winbase.h>
  26 #include <winreg.h>
  27 #include <initguid.h>
  28 #include <dispex.h>
  29 #include <wshom.h>
  30 #include <wine/test.h>
  31
  32 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  33
  34 #define EXPECT_HR(hr,hr_exp) \
  35     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
  36
  37 static void test_wshshell(void)
  38 {
  39     static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0};
  40     static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
  41     static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0};
  42     static const WCHAR pathW[] = {'%','P','A','T','H','%',0};
  43     static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
  44     static const WCHAR path2W[] = {'P','A','T','H',0};
  45     static const WCHAR dummydirW[] = {'d','e','a','d','p','a','r','r','o','t',0};
  46     static const WCHAR emptyW[] = {'e','m','p','t','y',0};
  47     IWshEnvironment *env;
  48     IWshExec *shexec;
  49     IWshShell3 *sh3;
  50     IDispatchEx *dispex;
  51     IWshCollection *coll;
  52     IDispatch *disp, *shortcut;
  53     IUnknown *shell, *unk;
  54     IFolderCollection *folders;
  55     IWshShortcut *shcut;
  56     ITypeInfo *ti;
  57     HRESULT hr;
  58     TYPEATTR *tattr;
  59     DISPPARAMS dp;
  60     EXCEPINFO ei;
  61     VARIANT arg, res, arg2;
  62     BSTR str, ret;
  63     DWORD retval;
  64     UINT err;
  65
  66     hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
  67             &IID_IDispatch, (void**)&disp);
  68     ok(hr == S_OK, "got 0x%08x\n", hr);
  69
  70     hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell);
  71     EXPECT_HR(hr, S_OK);
  72     IDispatch_Release(disp);
  73
  74     hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
  75     EXPECT_HR(hr, E_NOINTERFACE);
  76
  77     hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3);
  78     EXPECT_HR(hr, S_OK);
  79
  80     hr = IWshShell3_QueryInterface(sh3, &IID_IObjectWithSite, (void**)&unk);
  81     ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);
  82
  83     hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell, (void**)&unk);
  84     ok(hr == S_OK, "got 0x%08x\n", hr);
  85     IUnknown_Release(unk);
  86
  87     hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell2, (void**)&unk);
  88     ok(hr == S_OK, "got 0x%08x\n", hr);
  89     IUnknown_Release(unk);
  90
  91     hr = IWshShell3_get_SpecialFolders(sh3, &coll);
  92     EXPECT_HR(hr, S_OK);
  93
  94     hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders);
  95     EXPECT_HR(hr, E_NOINTERFACE);
  96
  97     hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp);
  98     EXPECT_HR(hr, S_OK);
  99
 100     hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti);
 101     EXPECT_HR(hr, S_OK);
 102
 103     hr = ITypeInfo_GetTypeAttr(ti, &tattr);
 104     EXPECT_HR(hr, S_OK);
 105     ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n");
 106     ITypeInfo_ReleaseTypeAttr(ti, tattr);
 107
 108     /* try to call Item() with normal IDispatch procedure */
 109     str = SysAllocString(desktopW);
 110     V_VT(&arg) = VT_BSTR;
 111     V_BSTR(&arg) = str;
 112     dp.rgvarg = &arg;
 113     dp.rgdispidNamedArgs = NULL;
 114     dp.cArgs = 1;
 115     dp.cNamedArgs = 0;
 116     hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err);
 117     EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND);
 118
 119     /* try Item() directly, it returns directory path apparently */
 120     V_VT(&res) = VT_EMPTY;
 121     hr = IWshCollection_Item(coll, &arg, &res);
 122     EXPECT_HR(hr, S_OK);
 123     ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res));
 124     SysFreeString(str);
 125     VariantClear(&res);
 126
 127     /* CreateShortcut() */
 128     str = SysAllocString(lnk1W);
 129     hr = IWshShell3_CreateShortcut(sh3, str, &shortcut);
 130     EXPECT_HR(hr, S_OK);
 131     SysFreeString(str);
 132     hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&shcut);
 133     EXPECT_HR(hr, S_OK);
 134
 135     hr = IWshShortcut_get_Arguments(shcut, NULL);
 136     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 137
 138     hr = IWshShortcut_get_IconLocation(shcut, NULL);
 139     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 140
 141     IWshShortcut_Release(shcut);
 142     IDispatch_Release(shortcut);
 143
 144     /* ExpandEnvironmentStrings */
 145     hr = IWshShell3_ExpandEnvironmentStrings(sh3, NULL, NULL);
 146     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 147
 148     str = SysAllocString(pathW);
 149     hr = IWshShell3_ExpandEnvironmentStrings(sh3, str, NULL);
 150     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 151     SysFreeString(str);
 152
 153     V_VT(&arg) = VT_BSTR;
 154     V_BSTR(&arg) = SysAllocString(sysW);
 155     hr = IWshShell3_get_Environment(sh3, &arg, &env);
 156     ok(hr == S_OK, "got 0x%08x\n", hr);
 157     VariantClear(&arg);
 158
 159     hr = IWshEnvironment_get_Item(env, NULL, NULL);
 160     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 161
 162     ret = (BSTR)0x1;
 163     hr = IWshEnvironment_get_Item(env, NULL, &ret);
 164     ok(hr == S_OK, "got 0x%08x\n", hr);
 165     ok(ret && !*ret, "got %p\n", ret);
 166     SysFreeString(ret);
 167
 168     /* invalid var name */
 169     str = SysAllocString(lnk1W);
 170     hr = IWshEnvironment_get_Item(env, str, NULL);
 171     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 172
 173     ret = NULL;
 174     hr = IWshEnvironment_get_Item(env, str, &ret);
 175     ok(hr == S_OK, "got 0x%08x\n", hr);
 176     ok(ret && *ret == 0, "got %s\n", wine_dbgstr_w(ret));
 177     SysFreeString(ret);
 178     SysFreeString(str);
 179
 180     /* valid name */
 181     str = SysAllocString(path2W);
 182     hr = IWshEnvironment_get_Item(env, str, &ret);
 183     ok(hr == S_OK, "got 0x%08x\n", hr);
 184     ok(ret && *ret != 0, "got %s\n", wine_dbgstr_w(ret));
 185     SysFreeString(ret);
 186     SysFreeString(str);
 187
 188     IWshEnvironment_Release(env);
 189
 190     V_VT(&arg) = VT_I2;
 191     V_I2(&arg) = 0;
 192     V_VT(&arg2) = VT_ERROR;
 193     V_ERROR(&arg2) = DISP_E_PARAMNOTFOUND;
 194
 195     str = SysAllocString(notepadW);
 196     hr = IWshShell3_Run(sh3, str, &arg, &arg2, NULL);
 197     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 198
 199     retval = 10;
 200     hr = IWshShell3_Run(sh3, str, NULL, &arg2, &retval);
 201     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 202     ok(retval == 10, "got %u\n", retval);
 203
 204     retval = 10;
 205     hr = IWshShell3_Run(sh3, str, &arg, NULL, &retval);
 206     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 207     ok(retval == 10, "got %u\n", retval);
 208
 209     retval = 10;
 210     V_VT(&arg2) = VT_ERROR;
 211     V_ERROR(&arg2) = 0;
 212     hr = IWshShell3_Run(sh3, str, &arg, &arg2, &retval);
 213     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
 214     ok(retval == 10, "got %u\n", retval);
 215
 216     SysFreeString(str);
 217
 218     /* current directory */
 219     if (0) /* crashes on native */
 220         hr = IWshShell3_get_CurrentDirectory(sh3, NULL);
 221
 222     str = NULL;
 223     hr = IWshShell3_get_CurrentDirectory(sh3, &str);
 224     ok(hr == S_OK, "got 0x%08x\n", hr);
 225     ok(str && str[0] != 0, "got empty string\n");
 226     SysFreeString(str);
 227
 228     hr = IWshShell3_put_CurrentDirectory(sh3, NULL);
 229     ok(hr == E_INVALIDARG ||
 230        broken(hr == HRESULT_FROM_WIN32(ERROR_NOACCESS)), "got 0x%08x\n", hr);
 231
 232     str = SysAllocString(emptyW);
 233     hr = IWshShell3_put_CurrentDirectory(sh3, str);
 234     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
 235     SysFreeString(str);
 236
 237     str = SysAllocString(dummydirW);
 238     hr = IWshShell3_put_CurrentDirectory(sh3, str);
 239     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
 240     SysFreeString(str);
 241
 242     /* Exec */
 243     hr = IWshShell3_Exec(sh3, NULL, NULL);
 244     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 245
 246     hr = IWshShell3_Exec(sh3, NULL, &shexec);
 247     ok(hr == DISP_E_EXCEPTION, "got 0x%08x\n", hr);
 248
 249     str = SysAllocString(emptyW);
 250     hr = IWshShell3_Exec(sh3, str, &shexec);
 251     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
 252     SysFreeString(str);
 253
 254     IWshCollection_Release(coll);
 255     IDispatch_Release(disp);
 256     IWshShell3_Release(sh3);
 257     IUnknown_Release(shell);
 258 }
 259
 260 /* delete key and all its subkeys */
 261 static DWORD delete_key(HKEY hkey)
 262 {
 263     char name[MAX_PATH];
 264     DWORD ret;
 265
 266     while (!(ret = RegEnumKeyA(hkey, 0, name, sizeof(name)))) {
 267         HKEY tmp;
 268         if (!(ret = RegOpenKeyExA(hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp))) {
 269             ret = delete_key(tmp);
 270             RegCloseKey(tmp);
 271         }
 272         if (ret) break;
 273     }
 274     if (ret != ERROR_NO_MORE_ITEMS) return ret;
 275     RegDeleteKeyA(hkey, "");
 276     return 0;
 277 }
 278
 279 static void test_registry(void)
 280 {
 281     static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
 282         'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0};
 283     static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0};
 284     static const WCHAR regszW[] = {'r','e','g','s','z',0};
 285     static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0};
 286     static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0};
 287     static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0};
 288
 289     static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
 290         'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0};
 291     static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
 292     static const WCHAR fooW[] = {'f','o','o',0};
 293     static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0};
 294     static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0};
 295     WCHAR pathW[MAX_PATH];
 296     DWORD dwvalue, type;
 297     VARIANT value, v;
 298     IWshShell3 *sh3;
 299     VARTYPE vartype;
 300     LONG bound;
 301     HRESULT hr;
 302     BSTR name;
 303     HKEY root;
 304     LONG ret;
 305     UINT dim;
 306
 307     hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 308             &IID_IWshShell3, (void**)&sh3);
 309     ok(hr == S_OK, "got 0x%08x\n", hr);
 310
 311     /* RegRead() */
 312     V_VT(&value) = VT_I2;
 313     hr = IWshShell3_RegRead(sh3, NULL, &value);
 314     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 315     ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
 316
 317     name = SysAllocString(brokenW);
 318     hr = IWshShell3_RegRead(sh3, name, NULL);
 319     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 320     V_VT(&value) = VT_I2;
 321     hr = IWshShell3_RegRead(sh3, name, &value);
 322     ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
 323     ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
 324     SysFreeString(name);
 325
 326     name = SysAllocString(broken2W);
 327     V_VT(&value) = VT_I2;
 328     hr = IWshShell3_RegRead(sh3, name, &value);
 329     ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
 330     ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
 331     SysFreeString(name);
 332
 333     ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
 334     ok(ret == 0, "got %d\n", ret);
 335
 336     ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7);
 337     ok(ret == 0, "got %d\n", ret);
 338
 339     ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9);
 340     ok(ret == 0, "got %d\n", ret);
 341
 342     ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9);
 343     ok(ret == 0, "got %d\n", ret);
 344
 345     dwvalue = 10;
 346     ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue));
 347     ok(ret == 0, "got %d\n", ret);
 348
 349     dwvalue = 11;
 350     ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue));
 351     ok(ret == 0, "got %d\n", ret);
 352
 353     /* REG_SZ */
 354     lstrcpyW(pathW, keypathW);
 355     lstrcatW(pathW, regszW);
 356     name = SysAllocString(pathW);
 357     VariantInit(&value);
 358     hr = IWshShell3_RegRead(sh3, name, &value);
 359     ok(hr == S_OK, "got 0x%08x\n", hr);
 360     ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
 361     ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value)));
 362     VariantClear(&value);
 363     SysFreeString(name);
 364
 365     /* REG_SZ with embedded NULL */
 366     lstrcpyW(pathW, keypathW);
 367     lstrcatW(pathW, regsz2W);
 368     name = SysAllocString(pathW);
 369     VariantInit(&value);
 370     hr = IWshShell3_RegRead(sh3, name, &value);
 371     ok(hr == S_OK, "got 0x%08x\n", hr);
 372     ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
 373     ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value)));
 374     VariantClear(&value);
 375     SysFreeString(name);
 376
 377     /* REG_DWORD */
 378     lstrcpyW(pathW, keypathW);
 379     lstrcatW(pathW, regdwordW);
 380     name = SysAllocString(pathW);
 381     VariantInit(&value);
 382     hr = IWshShell3_RegRead(sh3, name, &value);
 383     ok(hr == S_OK, "got 0x%08x\n", hr);
 384     ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value));
 385     ok(V_I4(&value) == 10, "got %d\n", V_I4(&value));
 386     SysFreeString(name);
 387
 388     /* REG_BINARY */
 389     lstrcpyW(pathW, keypathW);
 390     lstrcatW(pathW, regbinaryW);
 391     name = SysAllocString(pathW);
 392     VariantInit(&value);
 393     hr = IWshShell3_RegRead(sh3, name, &value);
 394     ok(hr == S_OK, "got 0x%08x\n", hr);
 395     ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
 396     dim = SafeArrayGetDim(V_ARRAY(&value));
 397     ok(dim == 1, "got %u\n", dim);
 398
 399     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
 400     ok(hr == S_OK, "got 0x%08x\n", hr);
 401     ok(bound == 0, "got %u\n", bound);
 402
 403     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
 404     ok(hr == S_OK, "got 0x%08x\n", hr);
 405     ok(bound == 3, "got %u\n", bound);
 406
 407     hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
 408     ok(hr == S_OK, "got 0x%08x\n", hr);
 409     ok(vartype == VT_VARIANT, "got %d\n", vartype);
 410
 411     bound = 0;
 412     hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
 413     ok(hr == S_OK, "got 0x%08x\n", hr);
 414     ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v));
 415     ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v));
 416     VariantClear(&v);
 417     VariantClear(&value);
 418     SysFreeString(name);
 419
 420     /* REG_MULTI_SZ */
 421     lstrcpyW(pathW, keypathW);
 422     lstrcatW(pathW, regmultiszW);
 423     name = SysAllocString(pathW);
 424     VariantInit(&value);
 425     hr = IWshShell3_RegRead(sh3, name, &value);
 426     ok(hr == S_OK, "got 0x%08x\n", hr);
 427     ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
 428     SysFreeString(name);
 429
 430     dim = SafeArrayGetDim(V_ARRAY(&value));
 431     ok(dim == 1, "got %u\n", dim);
 432
 433     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
 434     ok(hr == S_OK, "got 0x%08x\n", hr);
 435     ok(bound == 0, "got %u\n", bound);
 436
 437     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
 438     ok(hr == S_OK, "got 0x%08x\n", hr);
 439     ok(bound == 1, "got %u\n", bound);
 440
 441     hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
 442     ok(hr == S_OK, "got 0x%08x\n", hr);
 443     ok(vartype == VT_VARIANT, "got %d\n", vartype);
 444
 445     bound = 0;
 446     hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
 447     ok(hr == S_OK, "got 0x%08x\n", hr);
 448     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
 449     ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
 450     VariantClear(&v);
 451     VariantClear(&value);
 452
 453     name = SysAllocString(regsz1W);
 454     V_VT(&value) = VT_I2;
 455     hr = IWshShell3_RegRead(sh3, name, &value);
 456     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
 457     ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
 458     VariantClear(&value);
 459     SysFreeString(name);
 460
 461     delete_key(root);
 462
 463     /* RegWrite() */
 464     ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
 465     ok(ret == 0, "got %d\n", ret);
 466
 467     hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL);
 468     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 469
 470     lstrcpyW(pathW, keypathW);
 471     lstrcatW(pathW, regszW);
 472     name = SysAllocString(pathW);
 473
 474     hr = IWshShell3_RegWrite(sh3, name, NULL, NULL);
 475     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 476
 477     VariantInit(&value);
 478     hr = IWshShell3_RegWrite(sh3, name, &value, NULL);
 479     ok(hr == E_POINTER, "got 0x%08x\n", hr);
 480
 481     hr = IWshShell3_RegWrite(sh3, name, &value, &value);
 482     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 483
 484     /* type is optional */
 485     V_VT(&v) = VT_ERROR;
 486     V_ERROR(&v) = DISP_E_PARAMNOTFOUND;
 487     hr = IWshShell3_RegWrite(sh3, name, &value, &v);
 488     ok(hr == S_OK, "got 0x%08x\n", hr);
 489
 490     /* default type is REG_SZ */
 491     V_VT(&value) = VT_I4;
 492     V_I4(&value) = 12;
 493     hr = IWshShell3_RegWrite(sh3, name, &value, &v);
 494     ok(hr == S_OK, "got 0x%08x\n", hr);
 495
 496     type = REG_NONE;
 497     ret = RegQueryValueExA(root, "regsz", 0, &type, NULL, NULL);
 498     ok(ret == ERROR_SUCCESS, "got %d\n", ret);
 499     ok(type == REG_SZ, "got %d\n", type);
 500
 501     ret = RegDeleteValueA(root, "regsz");
 502     ok(ret == ERROR_SUCCESS, "got %d\n", ret);
 503     V_VT(&value) = VT_BSTR;
 504     V_BSTR(&value) = SysAllocString(regszW);
 505     hr = IWshShell3_RegWrite(sh3, name, &value, &v);
 506     ok(hr == S_OK, "got 0x%08x\n", hr);
 507     VariantClear(&value);
 508
 509     type = REG_NONE;
 510     ret = RegQueryValueExA(root, "regsz", 0, &type, NULL, NULL);
 511     ok(ret == ERROR_SUCCESS, "got %d\n", ret);
 512     ok(type == REG_SZ, "got %d\n", type);
 513
 514     ret = RegDeleteValueA(root, "regsz");
 515     ok(ret == ERROR_SUCCESS, "got %d\n", ret);
 516     V_VT(&value) = VT_R4;
 517     V_R4(&value) = 1.2;
 518     hr = IWshShell3_RegWrite(sh3, name, &value, &v);
 519     ok(hr == S_OK, "got 0x%08x\n", hr);
 520     VariantClear(&value);
 521
 522     type = REG_NONE;
 523     ret = RegQueryValueExA(root, "regsz", 0, &type, NULL, NULL);
 524     ok(ret == ERROR_SUCCESS, "got %d\n", ret);
 525     ok(type == REG_SZ, "got %d\n", type);
 526
 527     ret = RegDeleteValueA(root, "regsz");
 528     ok(ret == ERROR_SUCCESS, "got %d\n", ret);
 529     V_VT(&value) = VT_R4;
 530     V_R4(&value) = 1.2;
 531     V_VT(&v) = VT_I2;
 532     V_I2(&v) = 1;
 533     hr = IWshShell3_RegWrite(sh3, name, &value, &v);
 534     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 535     VariantClear(&value);
 536
 537     SysFreeString(name);
 538
 539     delete_key(root);
 540     IWshShell3_Release(sh3);
 541 }
 542
 543 START_TEST(wshom)
 544 {
 545     IUnknown *unk;
 546     HRESULT hr;
 547
 548     CoInitialize(NULL);
 549
 550     hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 551             &IID_IUnknown, (void**)&unk);
 552     if (FAILED(hr)) {
 553         win_skip("Could not create WshShell object: %08x\n", hr);
 554         return;
 555     }
 556     IUnknown_Release(unk);
 557
 558     test_wshshell();
 559     test_registry();
 560
 561     CoUninitialize();
 562 }