git.oblomov.eu Git - wine/blob - dlls/vbscript/tests/run.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 #include <stdio.h>
  20
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <ole2.h>
  25 #include <dispex.h>
  26 #include <activscp.h>
  27
  28 #include "wine/test.h"
  29
  30 extern const CLSID CLSID_VBScript;
  31
  32 #define DEFINE_EXPECT(func) \
  33     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  34
  35 #define SET_EXPECT(func) \
  36     expect_ ## func = TRUE
  37
  38 #define SET_CALLED(func) \
  39     called_ ## func = TRUE
  40
  41 #define CHECK_EXPECT2(func) \
  42     do { \
  43         ok(expect_ ##func, "unexpected call " #func "\n"); \
  44         called_ ## func = TRUE; \
  45     }while(0)
  46
  47 #define CHECK_EXPECT(func) \
  48     do { \
  49         CHECK_EXPECT2(func); \
  50         expect_ ## func = FALSE; \
  51     }while(0)
  52
  53 #define CHECK_CALLED(func) \
  54     do { \
  55         ok(called_ ## func, "expected " #func "\n"); \
  56         expect_ ## func = called_ ## func = FALSE; \
  57     }while(0)
  58
  59 DEFINE_EXPECT(global_success_d);
  60 DEFINE_EXPECT(global_success_i);
  61
  62 #define DISPID_GLOBAL_REPORTSUCCESS 1000
  63 #define DISPID_GLOBAL_TRACE         1001
  64 #define DISPID_GLOBAL_OK            1002
  65 #define DISPID_GLOBAL_GETVT         1003
  66
  67 static const WCHAR testW[] = {'t','e','s','t',0};
  68
  69 static BOOL strict_dispid_check;
  70 static const char *test_name = "(null)";
  71
  72 static BSTR a2bstr(const char *str)
  73 {
  74     BSTR ret;
  75     int len;
  76
  77     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  78     ret = SysAllocStringLen(NULL, len-1);
  79     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  80
  81     return ret;
  82 }
  83
  84 static int strcmp_wa(LPCWSTR strw, const char *stra)
  85 {
  86     CHAR buf[512];
  87     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
  88     return lstrcmpA(buf, stra);
  89 }
  90
  91 static const char *vt2a(VARIANT *v)
  92 {
  93     if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
  94         static char buf[64];
  95         sprintf(buf, "%s*", vt2a(V_BYREF(v)));
  96         return buf;
  97     }
  98
  99     switch(V_VT(v)) {
 100     case VT_EMPTY:
 101         return "VT_EMPTY";
 102     case VT_NULL:
 103         return "VT_NULL";
 104     case VT_I2:
 105         return "VT_I2";
 106     case VT_I4:
 107         return "VT_I4";
 108     case VT_R8:
 109         return "VT_R8";
 110     case VT_BSTR:
 111         return "VT_BSTR";
 112     case VT_DISPATCH:
 113         return "VT_DISPATCH";
 114     case VT_BOOL:
 115         return "VT_BOOL";
 116     case VT_ARRAY|VT_VARIANT:
 117         return "VT_ARRAY|VT_VARIANT";
 118     default:
 119         ok(0, "unknown vt %d\n", V_VT(v));
 120         return NULL;
 121     }
 122 }
 123
 124 #define test_grfdex(a,b) _test_grfdex(__LINE__,a,b)
 125 static void _test_grfdex(unsigned line, DWORD grfdex, DWORD expect)
 126 {
 127     ok_(__FILE__,line)(grfdex == expect, "grfdex = %x, expected %x\n", grfdex, expect);
 128 }
 129
 130 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 131 {
 132     *ppv = NULL;
 133
 134     if(IsEqualGUID(riid, &IID_IUnknown)
 135        || IsEqualGUID(riid, &IID_IDispatch)
 136        || IsEqualGUID(riid, &IID_IDispatchEx))
 137         *ppv = iface;
 138     else
 139         return E_NOINTERFACE;
 140
 141     return S_OK;
 142 }
 143
 144 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 145 {
 146     return 2;
 147 }
 148
 149 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 150 {
 151     return 1;
 152 }
 153
 154 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 155 {
 156     ok(0, "unexpected call\n");
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 161                                               LCID lcid, ITypeInfo **ppTInfo)
 162 {
 163     ok(0, "unexpected call\n");
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 168                                                 LPOLESTR *rgszNames, UINT cNames,
 169                                                 LCID lcid, DISPID *rgDispId)
 170 {
 171     ok(0, "unexpected call\n");
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 176                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 177                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 178 {
 179     ok(0, "unexpected call\n");
 180     return E_NOTIMPL;
 181 }
 182
 183 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 184 {
 185     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 190 {
 191     ok(0, "unexpected call\n");
 192     return E_NOTIMPL;
 193 }
 194
 195 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 196 {
 197     ok(0, "unexpected call\n");
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 202 {
 203     ok(0, "unexpected call\n");
 204     return E_NOTIMPL;
 205 }
 206
 207 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 208 {
 209     ok(0, "unexpected call\n");
 210     return E_NOTIMPL;
 211 }
 212
 213 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 214 {
 215     ok(0, "unexpected call\n");
 216     return E_NOTIMPL;
 217 }
 218
 219
 220 static HRESULT WINAPI Global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 221 {
 222     if(!strcmp_wa(bstrName, "ok")) {
 223         test_grfdex(grfdex, fdexNameCaseInsensitive);
 224         *pid = DISPID_GLOBAL_OK;
 225         return S_OK;
 226     }
 227     if(!strcmp_wa(bstrName, "trace")) {
 228         test_grfdex(grfdex, fdexNameCaseInsensitive);
 229         *pid = DISPID_GLOBAL_TRACE;
 230         return S_OK;
 231     }
 232     if(!strcmp_wa(bstrName, "reportSuccess")) {
 233         CHECK_EXPECT(global_success_d);
 234         test_grfdex(grfdex, fdexNameCaseInsensitive);
 235         *pid = DISPID_GLOBAL_REPORTSUCCESS;
 236         return S_OK;
 237     }
 238     if(!strcmp_wa(bstrName, "getVT")) {
 239         test_grfdex(grfdex, fdexNameCaseInsensitive);
 240         *pid = DISPID_GLOBAL_GETVT;
 241         return S_OK;
 242     }
 243
 244     if(strict_dispid_check && strcmp_wa(bstrName, "x"))
 245         ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 246     return DISP_E_UNKNOWNNAME;
 247 }
 248
 249 static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 250         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 251 {
 252     switch(id) {
 253     case DISPID_GLOBAL_OK: {
 254         VARIANT *b;
 255
 256         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 257         ok(pdp != NULL, "pdp == NULL\n");
 258         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 259         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 260         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 261         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 262         if(wFlags & INVOKE_PROPERTYGET)
 263             ok(pvarRes != NULL, "pvarRes == NULL\n");
 264         else
 265             ok(!pvarRes, "pvarRes != NULL\n");
 266         ok(pei != NULL, "pei == NULL\n");
 267
 268         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 269
 270         b = pdp->rgvarg+1;
 271         if(V_VT(b) == (VT_BYREF|VT_VARIANT))
 272             b = V_BYREF(b);
 273
 274         ok(V_VT(b) == VT_BOOL, "V_VT(b) = %d\n", V_VT(b));
 275
 276         ok(V_BOOL(b), "%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 277         return S_OK;
 278     }
 279
 280      case DISPID_GLOBAL_TRACE:
 281         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 282         ok(pdp != NULL, "pdp == NULL\n");
 283         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 284         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 285         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 286         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 287         ok(!pvarRes, "pvarRes != NULL\n");
 288         ok(pei != NULL, "pei == NULL\n");
 289
 290         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 291         if(V_VT(pdp->rgvarg) == VT_BSTR)
 292             trace("%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 293
 294         return S_OK;
 295
 296     case DISPID_GLOBAL_REPORTSUCCESS:
 297         CHECK_EXPECT(global_success_i);
 298
 299         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 300         ok(pdp != NULL, "pdp == NULL\n");
 301         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 302         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 303         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 304         ok(!pvarRes, "pvarRes != NULL\n");
 305         ok(pei != NULL, "pei == NULL\n");
 306
 307         return S_OK;
 308
 309     case DISPID_GLOBAL_GETVT:
 310          ok(pdp != NULL, "pdp == NULL\n");
 311          ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 312          ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 313          ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 314          ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 315          ok(pvarRes != NULL, "pvarRes == NULL\n");
 316          ok(V_VT(pvarRes) ==  VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
 317          ok(pei != NULL, "pei == NULL\n");
 318
 319          V_VT(pvarRes) = VT_BSTR;
 320          V_BSTR(pvarRes) = a2bstr(vt2a(pdp->rgvarg));
 321          return S_OK;
 322     }
 323
 324     ok(0, "unexpected call %d\n", id);
 325     return DISP_E_MEMBERNOTFOUND;
 326 }
 327
 328 static IDispatchExVtbl GlobalVtbl = {
 329     DispatchEx_QueryInterface,
 330     DispatchEx_AddRef,
 331     DispatchEx_Release,
 332     DispatchEx_GetTypeInfoCount,
 333     DispatchEx_GetTypeInfo,
 334     DispatchEx_GetIDsOfNames,
 335     DispatchEx_Invoke,
 336     Global_GetDispID,
 337     Global_InvokeEx,
 338     DispatchEx_DeleteMemberByName,
 339     DispatchEx_DeleteMemberByDispID,
 340     DispatchEx_GetMemberProperties,
 341     DispatchEx_GetMemberName,
 342     DispatchEx_GetNextDispID,
 343     DispatchEx_GetNameSpaceParent
 344 };
 345
 346 static IDispatchEx Global = { &GlobalVtbl };
 347
 348 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 349 {
 350     *ppv = NULL;
 351
 352     if(IsEqualGUID(&IID_IUnknown, riid))
 353         *ppv = iface;
 354     else if(IsEqualGUID(&IID_IActiveScriptSite, riid))
 355         *ppv = iface;
 356     else
 357         return E_NOINTERFACE;
 358
 359     IUnknown_AddRef((IUnknown*)*ppv);
 360     return S_OK;
 361 }
 362
 363 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 364 {
 365     return 2;
 366 }
 367
 368 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 369 {
 370     return 1;
 371 }
 372
 373 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 374 {
 375     *plcid = GetUserDefaultLCID();
 376     return S_OK;
 377 }
 378
 379 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 380         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 381 {
 382     ok(dwReturnMask == SCRIPTINFO_IUNKNOWN, "unexpected dwReturnMask %x\n", dwReturnMask);
 383     ok(!ppti, "ppti != NULL\n");
 384
 385     if(strcmp_wa(pstrName, "test"))
 386         ok(0, "unexpected pstrName %s\n", wine_dbgstr_w(pstrName));
 387
 388     *ppiunkItem = (IUnknown*)&Global;
 389     return S_OK;
 390 }
 391
 392 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 393 {
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 398         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 399 {
 400     return E_NOTIMPL;
 401 }
 402
 403 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 404 {
 405     return E_NOTIMPL;
 406 }
 407
 408 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 409 {
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 414 {
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 419 {
 420     return E_NOTIMPL;
 421 }
 422
 423 #undef ACTSCPSITE_THIS
 424
 425 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 426     ActiveScriptSite_QueryInterface,
 427     ActiveScriptSite_AddRef,
 428     ActiveScriptSite_Release,
 429     ActiveScriptSite_GetLCID,
 430     ActiveScriptSite_GetItemInfo,
 431     ActiveScriptSite_GetDocVersionString,
 432     ActiveScriptSite_OnScriptTerminate,
 433     ActiveScriptSite_OnStateChange,
 434     ActiveScriptSite_OnScriptError,
 435     ActiveScriptSite_OnEnterScript,
 436     ActiveScriptSite_OnLeaveScript
 437 };
 438
 439 static IActiveScriptSite ActiveScriptSite = { &ActiveScriptSiteVtbl };
 440
 441 static IActiveScript *create_script(void)
 442 {
 443     IActiveScript *script;
 444     HRESULT hres;
 445
 446     hres = CoCreateInstance(&CLSID_VBScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 447             &IID_IActiveScript, (void**)&script);
 448     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 449
 450     return script;
 451 }
 452
 453 static HRESULT parse_script(DWORD flags, BSTR script_str)
 454 {
 455     IActiveScriptParse *parser;
 456     IActiveScript *engine;
 457     IDispatch *script_disp;
 458     HRESULT hres;
 459
 460     engine = create_script();
 461     if(!engine)
 462         return S_OK;
 463
 464     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
 465     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 466     if (FAILED(hres))
 467     {
 468         IActiveScript_Release(engine);
 469         return hres;
 470     }
 471
 472     hres = IActiveScriptParse64_InitNew(parser);
 473     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 474
 475     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
 476     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 477
 478     hres = IActiveScript_AddNamedItem(engine, testW,
 479             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|flags);
 480     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 481
 482     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
 483     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 484
 485     hres = IActiveScript_GetScriptDispatch(engine, NULL, &script_disp);
 486     ok(hres == S_OK, "GetScriptDispatch failed: %08x\n", hres);
 487     ok(script_disp != NULL, "script_disp == NULL\n");
 488     ok(script_disp != (IDispatch*)&Global, "script_disp == Global\n");
 489
 490     hres = IActiveScriptParse64_ParseScriptText(parser, script_str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 491
 492     IDispatch_Release(script_disp);
 493     IActiveScript_Release(engine);
 494     IUnknown_Release(parser);
 495
 496     return hres;
 497 }
 498
 499 static void parse_script_af(DWORD flags, const char *src)
 500 {
 501     BSTR tmp;
 502     HRESULT hres;
 503
 504     tmp = a2bstr(src);
 505     hres = parse_script(flags, tmp);
 506     SysFreeString(tmp);
 507     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
 508 }
 509
 510 static void parse_script_a(const char *src)
 511 {
 512     parse_script_af(SCRIPTITEM_GLOBALMEMBERS, src);
 513 }
 514
 515 static BSTR get_script_from_file(const char *filename)
 516 {
 517     DWORD size, len;
 518     HANDLE file, map;
 519     const char *file_map;
 520     BSTR ret;
 521
 522     file = CreateFileA(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
 523     if(file == INVALID_HANDLE_VALUE) {
 524         trace("Could not open file: %u\n", GetLastError());
 525         return NULL;
 526     }
 527
 528     size = GetFileSize(file, NULL);
 529
 530     map = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
 531     CloseHandle(file);
 532     if(map == INVALID_HANDLE_VALUE) {
 533         trace("Could not create file mapping: %u\n", GetLastError());
 534         return NULL;
 535     }
 536
 537     file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 538     CloseHandle(map);
 539     if(!file_map) {
 540         trace("MapViewOfFile failed: %u\n", GetLastError());
 541         return NULL;
 542     }
 543
 544     len = MultiByteToWideChar(CP_ACP, 0, file_map, size, NULL, 0);
 545     ret = SysAllocStringLen(NULL, len);
 546     MultiByteToWideChar(CP_ACP, 0, file_map, size, ret, len);
 547
 548     UnmapViewOfFile(file_map);
 549
 550     return ret;
 551 }
 552
 553 static void run_from_file(const char *filename)
 554 {
 555     BSTR script_str;
 556     HRESULT hres;
 557
 558     script_str = get_script_from_file(filename);
 559     if(!script_str)
 560         return;
 561
 562     strict_dispid_check = FALSE;
 563     hres = parse_script(SCRIPTITEM_GLOBALMEMBERS, script_str);
 564     SysFreeString(script_str);
 565     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
 566 }
 567
 568 static void run_from_res(const char *name)
 569 {
 570     const char *data;
 571     DWORD size, len;
 572     BSTR str;
 573     HRSRC src;
 574     HRESULT hres;
 575
 576     strict_dispid_check = FALSE;
 577     test_name = name;
 578
 579     src = FindResourceA(NULL, name, (LPCSTR)40);
 580     ok(src != NULL, "Could not find resource %s\n", name);
 581
 582     size = SizeofResource(NULL, src);
 583     data = LoadResource(NULL, src);
 584
 585     len = MultiByteToWideChar(CP_ACP, 0, data, size, NULL, 0);
 586     str = SysAllocStringLen(NULL, len);
 587     MultiByteToWideChar(CP_ACP, 0, data, size, str, len);
 588
 589     SET_EXPECT(global_success_d);
 590     SET_EXPECT(global_success_i);
 591     hres = parse_script(SCRIPTITEM_GLOBALMEMBERS, str);
 592     CHECK_CALLED(global_success_d);
 593     CHECK_CALLED(global_success_i);
 594
 595     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
 596     SysFreeString(str);
 597 }
 598
 599 static void run_tests(void)
 600 {
 601     strict_dispid_check = TRUE;
 602
 603     parse_script_a("");
 604     parse_script_a("' empty ;");
 605
 606     SET_EXPECT(global_success_d);
 607     SET_EXPECT(global_success_i);
 608     parse_script_a("reportSuccess");
 609     CHECK_CALLED(global_success_d);
 610     CHECK_CALLED(global_success_i);
 611
 612     SET_EXPECT(global_success_d);
 613     SET_EXPECT(global_success_i);
 614     parse_script_a("reportSuccess()");
 615     CHECK_CALLED(global_success_d);
 616     CHECK_CALLED(global_success_i);
 617
 618     SET_EXPECT(global_success_d);
 619     SET_EXPECT(global_success_i);
 620     parse_script_a("Call reportSuccess");
 621     CHECK_CALLED(global_success_d);
 622     CHECK_CALLED(global_success_i);
 623
 624     run_from_res("lang.vbs");
 625 }
 626
 627 static BOOL check_vbscript(void)
 628 {
 629     IActiveScript *vbscript;
 630     HRESULT hres;
 631
 632     hres = CoCreateInstance(&CLSID_VBScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 633             &IID_IActiveScript, (void**)&vbscript);
 634     if(SUCCEEDED(hres))
 635         IActiveScript_Release(vbscript);
 636
 637     return hres == S_OK;
 638 }
 639
 640 START_TEST(run)
 641 {
 642     int argc;
 643     char **argv;
 644
 645     argc = winetest_get_mainargs(&argv);
 646
 647     CoInitialize(NULL);
 648
 649     if(!check_vbscript()) {
 650         win_skip("Broken engine, probably too old\n");
 651     }else if(argc > 2) {
 652         run_from_file(argv[2]);
 653     }else {
 654         run_tests();
 655     }
 656
 657     CoUninitialize();
 658 }