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
  64 static const WCHAR testW[] = {'t','e','s','t',0};
  65
  66 static BOOL strict_dispid_check;
  67
  68 static BSTR a2bstr(const char *str)
  69 {
  70     BSTR ret;
  71     int len;
  72
  73     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  74     ret = SysAllocStringLen(NULL, len-1);
  75     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  76
  77     return ret;
  78 }
  79
  80 static int strcmp_wa(LPCWSTR strw, const char *stra)
  81 {
  82     CHAR buf[512];
  83     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
  84     return lstrcmpA(buf, stra);
  85 }
  86
  87
  88 #define test_grfdex(a,b) _test_grfdex(__LINE__,a,b)
  89 static void _test_grfdex(unsigned line, DWORD grfdex, DWORD expect)
  90 {
  91     ok_(__FILE__,line)(grfdex == expect, "grfdex = %x, expected %x\n", grfdex, expect);
  92 }
  93
  94 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
  95 {
  96     *ppv = NULL;
  97
  98     if(IsEqualGUID(riid, &IID_IUnknown)
  99        || IsEqualGUID(riid, &IID_IDispatch)
 100        || IsEqualGUID(riid, &IID_IDispatchEx))
 101         *ppv = iface;
 102     else
 103         return E_NOINTERFACE;
 104
 105     return S_OK;
 106 }
 107
 108 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 109 {
 110     return 2;
 111 }
 112
 113 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 114 {
 115     return 1;
 116 }
 117
 118 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 119 {
 120     ok(0, "unexpected call\n");
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 125                                               LCID lcid, ITypeInfo **ppTInfo)
 126 {
 127     ok(0, "unexpected call\n");
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 132                                                 LPOLESTR *rgszNames, UINT cNames,
 133                                                 LCID lcid, DISPID *rgDispId)
 134 {
 135     ok(0, "unexpected call\n");
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 140                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 141                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 142 {
 143     ok(0, "unexpected call\n");
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 148 {
 149     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 154 {
 155     ok(0, "unexpected call\n");
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 160 {
 161     ok(0, "unexpected call\n");
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 166 {
 167     ok(0, "unexpected call\n");
 168     return E_NOTIMPL;
 169 }
 170
 171 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 172 {
 173     ok(0, "unexpected call\n");
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 178 {
 179     ok(0, "unexpected call\n");
 180     return E_NOTIMPL;
 181 }
 182
 183
 184 static HRESULT WINAPI Global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 185 {
 186     if(!strcmp_wa(bstrName, "reportSuccess")) {
 187         CHECK_EXPECT(global_success_d);
 188         test_grfdex(grfdex, fdexNameCaseInsensitive);
 189         *pid = DISPID_GLOBAL_REPORTSUCCESS;
 190         return S_OK;
 191     }
 192
 193     if(strict_dispid_check && strcmp_wa(bstrName, "x"))
 194         ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 195     return DISP_E_UNKNOWNNAME;
 196 }
 197
 198 static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 199         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 200 {
 201     switch(id) {
 202     case DISPID_GLOBAL_REPORTSUCCESS:
 203         CHECK_EXPECT(global_success_i);
 204
 205         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 206         ok(pdp != NULL, "pdp == NULL\n");
 207         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 208         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 209         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 210         ok(!pvarRes, "pvarRes != NULL\n");
 211         ok(pei != NULL, "pei == NULL\n");
 212
 213         return S_OK;
 214     }
 215
 216     ok(0, "unexpected call %d\n", id);
 217     return DISP_E_MEMBERNOTFOUND;
 218 }
 219
 220 static IDispatchExVtbl GlobalVtbl = {
 221     DispatchEx_QueryInterface,
 222     DispatchEx_AddRef,
 223     DispatchEx_Release,
 224     DispatchEx_GetTypeInfoCount,
 225     DispatchEx_GetTypeInfo,
 226     DispatchEx_GetIDsOfNames,
 227     DispatchEx_Invoke,
 228     Global_GetDispID,
 229     Global_InvokeEx,
 230     DispatchEx_DeleteMemberByName,
 231     DispatchEx_DeleteMemberByDispID,
 232     DispatchEx_GetMemberProperties,
 233     DispatchEx_GetMemberName,
 234     DispatchEx_GetNextDispID,
 235     DispatchEx_GetNameSpaceParent
 236 };
 237
 238 static IDispatchEx Global = { &GlobalVtbl };
 239
 240 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 241 {
 242     *ppv = NULL;
 243
 244     if(IsEqualGUID(&IID_IUnknown, riid))
 245         *ppv = iface;
 246     else if(IsEqualGUID(&IID_IActiveScriptSite, riid))
 247         *ppv = iface;
 248     else
 249         return E_NOINTERFACE;
 250
 251     IUnknown_AddRef((IUnknown*)*ppv);
 252     return S_OK;
 253 }
 254
 255 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 256 {
 257     return 2;
 258 }
 259
 260 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 261 {
 262     return 1;
 263 }
 264
 265 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 266 {
 267     *plcid = GetUserDefaultLCID();
 268     return S_OK;
 269 }
 270
 271 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 272         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 273 {
 274     ok(dwReturnMask == SCRIPTINFO_IUNKNOWN, "unexpected dwReturnMask %x\n", dwReturnMask);
 275     ok(!ppti, "ppti != NULL\n");
 276
 277     if(strcmp_wa(pstrName, "test"))
 278         ok(0, "unexpected pstrName %s\n", wine_dbgstr_w(pstrName));
 279
 280     *ppiunkItem = (IUnknown*)&Global;
 281     return S_OK;
 282 }
 283
 284 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 285 {
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 290         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 291 {
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 296 {
 297     return E_NOTIMPL;
 298 }
 299
 300 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 301 {
 302     return E_NOTIMPL;
 303 }
 304
 305 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 306 {
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 311 {
 312     return E_NOTIMPL;
 313 }
 314
 315 #undef ACTSCPSITE_THIS
 316
 317 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 318     ActiveScriptSite_QueryInterface,
 319     ActiveScriptSite_AddRef,
 320     ActiveScriptSite_Release,
 321     ActiveScriptSite_GetLCID,
 322     ActiveScriptSite_GetItemInfo,
 323     ActiveScriptSite_GetDocVersionString,
 324     ActiveScriptSite_OnScriptTerminate,
 325     ActiveScriptSite_OnStateChange,
 326     ActiveScriptSite_OnScriptError,
 327     ActiveScriptSite_OnEnterScript,
 328     ActiveScriptSite_OnLeaveScript
 329 };
 330
 331 static IActiveScriptSite ActiveScriptSite = { &ActiveScriptSiteVtbl };
 332
 333 static IActiveScript *create_script(void)
 334 {
 335     IActiveScript *script;
 336     HRESULT hres;
 337
 338     hres = CoCreateInstance(&CLSID_VBScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 339             &IID_IActiveScript, (void**)&script);
 340     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 341
 342     return script;
 343 }
 344
 345 static HRESULT parse_script(DWORD flags, BSTR script_str)
 346 {
 347     IActiveScriptParse *parser;
 348     IActiveScript *engine;
 349     IDispatch *script_disp;
 350     HRESULT hres;
 351
 352     engine = create_script();
 353     if(!engine)
 354         return S_OK;
 355
 356     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
 357     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 358     if (FAILED(hres))
 359     {
 360         IActiveScript_Release(engine);
 361         return hres;
 362     }
 363
 364     hres = IActiveScriptParse64_InitNew(parser);
 365     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 366
 367     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
 368     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 369
 370     hres = IActiveScript_AddNamedItem(engine, testW,
 371             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|flags);
 372     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 373
 374     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
 375     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 376
 377     hres = IActiveScript_GetScriptDispatch(engine, NULL, &script_disp);
 378     ok(hres == S_OK, "GetScriptDispatch failed: %08x\n", hres);
 379     ok(script_disp != NULL, "script_disp == NULL\n");
 380     ok(script_disp != (IDispatch*)&Global, "script_disp == Global\n");
 381
 382     hres = IActiveScriptParse64_ParseScriptText(parser, script_str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 383
 384     IDispatch_Release(script_disp);
 385     IActiveScript_Release(engine);
 386     IUnknown_Release(parser);
 387
 388     return hres;
 389 }
 390
 391 static void parse_script_af(DWORD flags, const char *src)
 392 {
 393     BSTR tmp;
 394     HRESULT hres;
 395
 396     tmp = a2bstr(src);
 397     hres = parse_script(flags, tmp);
 398     SysFreeString(tmp);
 399     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
 400 }
 401
 402 static void parse_script_a(const char *src)
 403 {
 404     parse_script_af(SCRIPTITEM_GLOBALMEMBERS, src);
 405 }
 406
 407 static BSTR get_script_from_file(const char *filename)
 408 {
 409     DWORD size, len;
 410     HANDLE file, map;
 411     const char *file_map;
 412     BSTR ret;
 413
 414     file = CreateFileA(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
 415     if(file == INVALID_HANDLE_VALUE) {
 416         trace("Could not open file: %u\n", GetLastError());
 417         return NULL;
 418     }
 419
 420     size = GetFileSize(file, NULL);
 421
 422     map = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
 423     CloseHandle(file);
 424     if(map == INVALID_HANDLE_VALUE) {
 425         trace("Could not create file mapping: %u\n", GetLastError());
 426         return NULL;
 427     }
 428
 429     file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 430     CloseHandle(map);
 431     if(!file_map) {
 432         trace("MapViewOfFile failed: %u\n", GetLastError());
 433         return NULL;
 434     }
 435
 436     len = MultiByteToWideChar(CP_ACP, 0, file_map, size, NULL, 0);
 437     ret = SysAllocStringLen(NULL, len);
 438     MultiByteToWideChar(CP_ACP, 0, file_map, size, ret, len);
 439
 440     UnmapViewOfFile(file_map);
 441
 442     return ret;
 443 }
 444
 445 static void run_from_file(const char *filename)
 446 {
 447     BSTR script_str;
 448     HRESULT hres;
 449
 450     script_str = get_script_from_file(filename);
 451     if(!script_str)
 452         return;
 453
 454     strict_dispid_check = FALSE;
 455     hres = parse_script(SCRIPTITEM_GLOBALMEMBERS, script_str);
 456     SysFreeString(script_str);
 457     ok(hres == S_OK, "parse_script failed: %08x\n", hres);
 458 }
 459
 460 static void run_tests(void)
 461 {
 462     strict_dispid_check = TRUE;
 463
 464     parse_script_a("");
 465     parse_script_a("' empty ;");
 466
 467     SET_EXPECT(global_success_d);
 468     SET_EXPECT(global_success_i);
 469     parse_script_a("reportSuccess");
 470     CHECK_CALLED(global_success_d);
 471     CHECK_CALLED(global_success_i);
 472
 473     SET_EXPECT(global_success_d);
 474     SET_EXPECT(global_success_i);
 475     parse_script_a("reportSuccess()");
 476     CHECK_CALLED(global_success_d);
 477     CHECK_CALLED(global_success_i);
 478
 479     SET_EXPECT(global_success_d);
 480     SET_EXPECT(global_success_i);
 481     parse_script_a("Call reportSuccess");
 482     CHECK_CALLED(global_success_d);
 483     CHECK_CALLED(global_success_i);
 484 }
 485
 486 static BOOL check_vbscript(void)
 487 {
 488     IActiveScript *vbscript;
 489     HRESULT hres;
 490
 491     hres = CoCreateInstance(&CLSID_VBScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 492             &IID_IActiveScript, (void**)&vbscript);
 493     if(SUCCEEDED(hres))
 494         IActiveScript_Release(vbscript);
 495
 496     return hres == S_OK;
 497 }
 498
 499 START_TEST(run)
 500 {
 501     int argc;
 502     char **argv;
 503
 504     argc = winetest_get_mainargs(&argv);
 505
 506     CoInitialize(NULL);
 507
 508     if(!check_vbscript()) {
 509         win_skip("Broken engine, probably too old\n");
 510     }else if(argc > 2) {
 511         run_from_file(argv[2]);
 512     }else {
 513         run_tests();
 514     }
 515
 516     CoUninitialize();
 517 }