git.oblomov.eu Git - wine/blob - dlls/jscript/tests/run.c

   1 /*
   2  * Copyright 2008 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 static const CLSID CLSID_JScript =
  31     {0xf414c260,0x6ac0,0x11cf,{0xb6,0xd1,0x00,0xaa,0x00,0xbb,0xbb,0x58}};
  32
  33 #define DEFINE_EXPECT(func) \
  34     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  35
  36 #define SET_EXPECT(func) \
  37     expect_ ## func = TRUE
  38
  39 #define SET_CALLED(func) \
  40     called_ ## func = TRUE
  41
  42 #define CHECK_EXPECT2(func) \
  43     do { \
  44         ok(expect_ ##func, "unexpected call " #func "\n"); \
  45         called_ ## func = TRUE; \
  46     }while(0)
  47
  48 #define CHECK_EXPECT(func) \
  49     do { \
  50         CHECK_EXPECT2(func); \
  51         expect_ ## func = FALSE; \
  52     }while(0)
  53
  54 #define CHECK_CALLED(func) \
  55     do { \
  56         ok(called_ ## func, "expected " #func "\n"); \
  57         expect_ ## func = called_ ## func = FALSE; \
  58     }while(0)
  59
  60 DEFINE_EXPECT(global_propget_d);
  61 DEFINE_EXPECT(global_propget_i);
  62 DEFINE_EXPECT(global_propput_d);
  63 DEFINE_EXPECT(global_propput_i);
  64 DEFINE_EXPECT(global_success_d);
  65 DEFINE_EXPECT(global_success_i);
  66 DEFINE_EXPECT(testobj_delete);
  67 DEFINE_EXPECT(GetItemInfo_testVal);
  68
  69 #define DISPID_GLOBAL_TESTPROPGET   0x1000
  70 #define DISPID_GLOBAL_TESTPROPPUT   0x1001
  71 #define DISPID_GLOBAL_REPORTSUCCESS 0x1002
  72 #define DISPID_GLOBAL_TRACE         0x1003
  73 #define DISPID_GLOBAL_OK            0x1004
  74 #define DISPID_GLOBAL_GETVT         0x1005
  75 #define DISPID_GLOBAL_TESTOBJ       0x1006
  76 #define DISPID_GLOBAL_NULL_BSTR     0x1007
  77
  78 static const WCHAR testW[] = {'t','e','s','t',0};
  79 static const CHAR testA[] = "test";
  80 static const WCHAR test_valW[] = {'t','e','s','t','V','a','l',0};
  81 static const CHAR test_valA[] = "testVal";
  82
  83 static BOOL strict_dispid_check;
  84 static const char *test_name = "(null)";
  85
  86 static const char *debugstr_w(LPCWSTR str)
  87 {
  88     static char buf[1024];
  89
  90     if(!str)
  91         return "(null)";
  92
  93     WideCharToMultiByte(CP_ACP, 0, str, -1, buf, sizeof(buf), NULL, NULL);
  94     return buf;
  95 }
  96
  97 static BSTR a2bstr(const char *str)
  98 {
  99     BSTR ret;
 100     int len;
 101
 102     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 103     ret = SysAllocStringLen(NULL, len-1);
 104     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 105
 106     return ret;
 107 }
 108
 109 static int strcmp_wa(LPCWSTR strw, const char *stra)
 110 {
 111     CHAR buf[512];
 112     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
 113     return lstrcmpA(buf, stra);
 114 }
 115
 116 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 117 {
 118     *ppv = NULL;
 119
 120     if(IsEqualGUID(riid, &IID_IUnknown)
 121        || IsEqualGUID(riid, &IID_IDispatch)
 122        || IsEqualGUID(riid, &IID_IDispatchEx))
 123         *ppv = iface;
 124     else
 125         return E_NOINTERFACE;
 126
 127     return S_OK;
 128 }
 129
 130 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 131 {
 132     return 2;
 133 }
 134
 135 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 136 {
 137     return 1;
 138 }
 139
 140 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 141 {
 142     ok(0, "unexpected call\n");
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 147                                               LCID lcid, ITypeInfo **ppTInfo)
 148 {
 149     ok(0, "unexpected call\n");
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 154                                                 LPOLESTR *rgszNames, UINT cNames,
 155                                                 LCID lcid, DISPID *rgDispId)
 156 {
 157     ok(0, "unexpected call\n");
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 162                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 163                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 164 {
 165     ok(0, "unexpected call\n");
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 170 {
 171     ok(0, "unexpected call %s %x\n", debugstr_w(bstrName), grfdex);
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 176 {
 177     ok(0, "unexpected call\n");
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 182 {
 183     ok(0, "unexpected call\n");
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 188 {
 189     ok(0, "unexpected call\n");
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 194 {
 195     ok(0, "unexpected call\n");
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 200 {
 201     ok(0, "unexpected call\n");
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 206 {
 207     ok(0, "unexpected call\n");
 208     return E_NOTIMPL;
 209 }
 210
 211 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 212         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 213 {
 214     ok(0, "unexpected call\n");
 215     return E_NOTIMPL;
 216 }
 217
 218 static HRESULT WINAPI testObj_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 219 {
 220     CHECK_EXPECT(testobj_delete);
 221
 222     ok(!strcmp_wa(bstrName, "deleteTest"), "unexpected name %s\n", debugstr_w(bstrName));
 223     ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 224     return S_OK;
 225 }
 226
 227 static IDispatchExVtbl testObjVtbl = {
 228     DispatchEx_QueryInterface,
 229     DispatchEx_AddRef,
 230     DispatchEx_Release,
 231     DispatchEx_GetTypeInfoCount,
 232     DispatchEx_GetTypeInfo,
 233     DispatchEx_GetIDsOfNames,
 234     DispatchEx_Invoke,
 235     DispatchEx_GetDispID,
 236     DispatchEx_InvokeEx,
 237     testObj_DeleteMemberByName,
 238     DispatchEx_DeleteMemberByDispID,
 239     DispatchEx_GetMemberProperties,
 240     DispatchEx_GetMemberName,
 241     DispatchEx_GetNextDispID,
 242     DispatchEx_GetNameSpaceParent
 243 };
 244
 245 static IDispatchEx testObj = { &testObjVtbl };
 246
 247 static HRESULT WINAPI Global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 248 {
 249     if(!strcmp_wa(bstrName, "ok")) {
 250         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 251         *pid = DISPID_GLOBAL_OK;
 252         return S_OK;
 253     }
 254     if(!strcmp_wa(bstrName, "trace")) {
 255         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 256         *pid = DISPID_GLOBAL_TRACE;
 257         return S_OK;
 258     }
 259     if(!strcmp_wa(bstrName, "reportSuccess")) {
 260         CHECK_EXPECT(global_success_d);
 261         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 262         *pid = DISPID_GLOBAL_REPORTSUCCESS;
 263         return S_OK;
 264     }
 265     if(!strcmp_wa(bstrName, "testPropGet")) {
 266         CHECK_EXPECT(global_propget_d);
 267         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 268         *pid = DISPID_GLOBAL_TESTPROPGET;
 269         return S_OK;
 270     }
 271     if(!strcmp_wa(bstrName, "testPropPut")) {
 272         CHECK_EXPECT(global_propput_d);
 273         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 274         *pid = DISPID_GLOBAL_TESTPROPPUT;
 275         return S_OK;
 276     }
 277     if(!strcmp_wa(bstrName, "getVT")) {
 278         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 279         *pid = DISPID_GLOBAL_GETVT;
 280         return S_OK;
 281     }
 282     if(!strcmp_wa(bstrName, "testObj")) {
 283         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 284         *pid = DISPID_GLOBAL_TESTOBJ;
 285         return S_OK;
 286     }
 287     if(!strcmp_wa(bstrName, "createNullBSTR")) {
 288         *pid = DISPID_GLOBAL_NULL_BSTR;
 289         return S_OK;
 290     }
 291
 292     if(strict_dispid_check)
 293         ok(0, "unexpected call %s\n", debugstr_w(bstrName));
 294     return DISP_E_UNKNOWNNAME;
 295 }
 296
 297 static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 298         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 299 {
 300     switch(id) {
 301     case DISPID_GLOBAL_OK:
 302         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 303         ok(pdp != NULL, "pdp == NULL\n");
 304         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 305         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 306         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 307         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 308         if(wFlags & INVOKE_PROPERTYGET)
 309             ok(pvarRes != NULL, "pvarRes == NULL\n");
 310         else
 311             ok(!pvarRes, "pvarRes != NULL\n");
 312         ok(pei != NULL, "pei == NULL\n");
 313
 314         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 315         ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg));
 316         ok(V_BOOL(pdp->rgvarg+1), "%s: %s\n", test_name, debugstr_w(V_BSTR(pdp->rgvarg)));
 317
 318         return S_OK;
 319
 320      case DISPID_GLOBAL_TRACE:
 321         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 322         ok(pdp != NULL, "pdp == NULL\n");
 323         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 324         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 325         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 326         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 327         ok(!pvarRes, "pvarRes != NULL\n");
 328         ok(pei != NULL, "pei == NULL\n");
 329
 330         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 331         if(V_VT(pdp->rgvarg) == VT_BSTR)
 332             trace("%s: %s\n", test_name, debugstr_w(V_BSTR(pdp->rgvarg)));
 333
 334         return S_OK;
 335
 336     case DISPID_GLOBAL_REPORTSUCCESS:
 337         CHECK_EXPECT(global_success_i);
 338
 339         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 340         ok(pdp != NULL, "pdp == NULL\n");
 341         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 342         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 343         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 344         ok(!pvarRes, "pvarRes != NULL\n");
 345         ok(pei != NULL, "pei == NULL\n");
 346
 347         return S_OK;
 348
 349      case DISPID_GLOBAL_TESTPROPGET:
 350         CHECK_EXPECT(global_propget_i);
 351
 352         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 353         ok(pdp != NULL, "pdp == NULL\n");
 354         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 355         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 356         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 357         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 358         ok(pvarRes != NULL, "pvarRes == NULL\n");
 359         ok(V_VT(pvarRes) ==  VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
 360         ok(pei != NULL, "pei == NULL\n");
 361
 362         V_VT(pvarRes) = VT_I4;
 363         V_I4(pvarRes) = 1;
 364
 365         return S_OK;
 366
 367     case DISPID_GLOBAL_TESTPROPPUT:
 368         CHECK_EXPECT(global_propput_i);
 369
 370         ok(wFlags == INVOKE_PROPERTYPUT, "wFlags = %x\n", wFlags);
 371         ok(pdp != NULL, "pdp == NULL\n");
 372         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 373         ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
 374         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 375         ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
 376         ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 377         ok(!pvarRes, "pvarRes != NULL\n");
 378
 379         ok(V_VT(pdp->rgvarg) == VT_I4, "V_VT(pdp->rgvarg)=%d\n", V_VT(pdp->rgvarg));
 380         ok(V_I4(pdp->rgvarg) == 1, "V_I4(pdp->rgvarg)=%d\n", V_I4(pdp->rgvarg));
 381         return S_OK;
 382
 383      case DISPID_GLOBAL_GETVT:
 384         ok(pdp != NULL, "pdp == NULL\n");
 385         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 386         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 387         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 388         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 389         ok(pvarRes != NULL, "pvarRes == NULL\n");
 390         ok(V_VT(pvarRes) ==  VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
 391         ok(pei != NULL, "pei == NULL\n");
 392
 393         V_VT(pvarRes) = VT_BSTR;
 394         switch(V_VT(pdp->rgvarg)) {
 395         case VT_EMPTY:
 396             V_BSTR(pvarRes) = a2bstr("VT_EMPTY");
 397             break;
 398         case VT_NULL:
 399             V_BSTR(pvarRes) = a2bstr("VT_NULL");
 400             break;
 401         case VT_I4:
 402             V_BSTR(pvarRes) = a2bstr("VT_I4");
 403             break;
 404         case VT_R8:
 405             V_BSTR(pvarRes) = a2bstr("VT_R8");
 406             break;
 407         case VT_BSTR:
 408             V_BSTR(pvarRes) = a2bstr("VT_BSTR");
 409             break;
 410         case VT_DISPATCH:
 411             V_BSTR(pvarRes) = a2bstr("VT_DISPATCH");
 412             break;
 413         case VT_BOOL:
 414             V_BSTR(pvarRes) = a2bstr("VT_BOOL");
 415             break;
 416         default:
 417             ok(0, "unknown vt %d\n", V_VT(pdp->rgvarg));
 418             return E_FAIL;
 419         }
 420
 421         return S_OK;
 422
 423     case DISPID_GLOBAL_TESTOBJ:
 424         ok(wFlags == INVOKE_PROPERTYGET, "wFlags = %x\n", wFlags);
 425         ok(pdp != NULL, "pdp == NULL\n");
 426         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 427         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 428         ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
 429         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 430         ok(pvarRes != NULL, "pvarRes == NULL\n");
 431         ok(V_VT(pvarRes) ==  VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
 432         ok(pei != NULL, "pei == NULL\n");
 433
 434         V_VT(pvarRes) = VT_DISPATCH;
 435         V_DISPATCH(pvarRes) = (IDispatch*)&testObj;
 436         return S_OK;
 437
 438     case DISPID_GLOBAL_NULL_BSTR:
 439         if(pvarRes) {
 440             V_VT(pvarRes) = VT_BSTR;
 441             V_BSTR(pvarRes) = NULL;
 442         }
 443         return S_OK;
 444     }
 445
 446     ok(0, "unexpected call %x\n", id);
 447     return DISP_E_MEMBERNOTFOUND;
 448 }
 449
 450 static IDispatchExVtbl GlobalVtbl = {
 451     DispatchEx_QueryInterface,
 452     DispatchEx_AddRef,
 453     DispatchEx_Release,
 454     DispatchEx_GetTypeInfoCount,
 455     DispatchEx_GetTypeInfo,
 456     DispatchEx_GetIDsOfNames,
 457     DispatchEx_Invoke,
 458     Global_GetDispID,
 459     Global_InvokeEx,
 460     DispatchEx_DeleteMemberByName,
 461     DispatchEx_DeleteMemberByDispID,
 462     DispatchEx_GetMemberProperties,
 463     DispatchEx_GetMemberName,
 464     DispatchEx_GetNextDispID,
 465     DispatchEx_GetNameSpaceParent
 466 };
 467
 468 static IDispatchEx Global = { &GlobalVtbl };
 469
 470 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 471 {
 472     *ppv = NULL;
 473
 474     if(IsEqualGUID(&IID_IUnknown, riid))
 475         *ppv = iface;
 476     else if(IsEqualGUID(&IID_IActiveScriptSite, riid))
 477         *ppv = iface;
 478     else
 479         return E_NOINTERFACE;
 480
 481     IUnknown_AddRef((IUnknown*)*ppv);
 482     return S_OK;
 483 }
 484
 485 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 486 {
 487     return 2;
 488 }
 489
 490 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 491 {
 492     return 1;
 493 }
 494
 495 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 496 {
 497     *plcid = GetUserDefaultLCID();
 498     return S_OK;
 499 }
 500
 501 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 502         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 503 {
 504     ok(dwReturnMask == SCRIPTINFO_IUNKNOWN, "unexpected dwReturnMask %x\n", dwReturnMask);
 505     ok(!ppti, "ppti != NULL\n");
 506
 507     if(!strcmp_wa(pstrName, test_valA))
 508         CHECK_EXPECT(GetItemInfo_testVal);
 509     else if(strcmp_wa(pstrName, testA))
 510         ok(0, "unexpected pstrName %s\n", debugstr_w(pstrName));
 511
 512     *ppiunkItem = (IUnknown*)&Global;
 513     return S_OK;
 514 }
 515
 516 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 517 {
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 522         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 523 {
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 528 {
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 533 {
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 538 {
 539     return E_NOTIMPL;
 540 }
 541
 542 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 543 {
 544     return E_NOTIMPL;
 545 }
 546
 547 #undef ACTSCPSITE_THIS
 548
 549 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 550     ActiveScriptSite_QueryInterface,
 551     ActiveScriptSite_AddRef,
 552     ActiveScriptSite_Release,
 553     ActiveScriptSite_GetLCID,
 554     ActiveScriptSite_GetItemInfo,
 555     ActiveScriptSite_GetDocVersionString,
 556     ActiveScriptSite_OnScriptTerminate,
 557     ActiveScriptSite_OnStateChange,
 558     ActiveScriptSite_OnScriptError,
 559     ActiveScriptSite_OnEnterScript,
 560     ActiveScriptSite_OnLeaveScript
 561 };
 562
 563 static IActiveScriptSite ActiveScriptSite = { &ActiveScriptSiteVtbl };
 564
 565 static IActiveScript *create_script(void)
 566 {
 567     IActiveScript *script;
 568     HRESULT hres;
 569
 570     hres = CoCreateInstance(&CLSID_JScript, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 571             &IID_IActiveScript, (void**)&script);
 572     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 573
 574     return script;
 575 }
 576
 577 static void parse_script(BSTR script_str)
 578 {
 579     IActiveScriptParse *parser;
 580     IActiveScript *engine;
 581     HRESULT hres;
 582
 583     engine = create_script();
 584     if(!engine)
 585         return;
 586
 587     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
 588     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 589     if (FAILED(hres))
 590     {
 591         IActiveScript_Release(engine);
 592         return;
 593     }
 594
 595     hres = IActiveScriptParse64_InitNew(parser);
 596     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 597
 598     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
 599     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 600
 601     hres = IActiveScript_AddNamedItem(engine, testW,
 602             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 603     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 604
 605     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
 606     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 607
 608     hres = IActiveScriptParse64_ParseScriptText(parser, script_str, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 609     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 610
 611     IActiveScript_Release(engine);
 612     IUnknown_Release(parser);
 613 }
 614
 615 static HRESULT parse_htmlscript(BSTR script_str)
 616 {
 617     IActiveScriptParse *parser;
 618     IActiveScript *engine;
 619     HRESULT hres;
 620     BSTR tmp = a2bstr("</SCRIPT>");
 621
 622     engine = create_script();
 623     if(!engine)
 624         return E_FAIL;
 625
 626     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
 627     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 628     if (FAILED(hres))
 629     {
 630         IActiveScript_Release(engine);
 631         return E_FAIL;
 632     }
 633
 634     hres = IActiveScriptParse64_InitNew(parser);
 635     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 636
 637     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
 638     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 639
 640     hres = IActiveScript_AddNamedItem(engine, testW,
 641             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 642     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 643
 644     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
 645     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 646
 647     hres = IActiveScriptParse64_ParseScriptText(parser, script_str, NULL, NULL, tmp, 0, 0, 0, NULL, NULL);
 648
 649     IActiveScript_Release(engine);
 650     IUnknown_Release(parser);
 651     SysFreeString(tmp);
 652
 653     return hres;
 654 }
 655
 656 static void parse_script_a(const char *src)
 657 {
 658     BSTR tmp = a2bstr(src);
 659     parse_script(tmp);
 660     SysFreeString(tmp);
 661 }
 662
 663 static HRESULT parse_htmlscript_a(const char *src)
 664 {
 665     HRESULT hres;
 666     BSTR tmp = a2bstr(src);
 667     hres = parse_htmlscript(tmp);
 668     SysFreeString(tmp);
 669
 670     return hres;
 671 }
 672
 673 static BSTR get_script_from_file(const char *filename)
 674 {
 675     DWORD size, len;
 676     HANDLE file, map;
 677     const char *file_map;
 678     BSTR ret;
 679
 680     file = CreateFileA(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
 681     if(file == INVALID_HANDLE_VALUE) {
 682         trace("Could not open file: %u\n", GetLastError());
 683         return NULL;
 684     }
 685
 686     size = GetFileSize(file, NULL);
 687
 688     map = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
 689     CloseHandle(file);
 690     if(map == INVALID_HANDLE_VALUE) {
 691         trace("Could not create file mapping: %u\n", GetLastError());
 692         return NULL;
 693     }
 694
 695     file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 696     CloseHandle(map);
 697     if(!file_map) {
 698         trace("MapViewOfFile failed: %u\n", GetLastError());
 699         return NULL;
 700     }
 701
 702     len = MultiByteToWideChar(CP_ACP, 0, file_map, size, NULL, 0);
 703     ret = SysAllocStringLen(NULL, len);
 704     MultiByteToWideChar(CP_ACP, 0, file_map, size, ret, len);
 705
 706     UnmapViewOfFile(file_map);
 707
 708     return ret;
 709 }
 710
 711 static void run_from_file(const char *filename)
 712 {
 713     BSTR script_str = get_script_from_file(filename);
 714
 715     strict_dispid_check = FALSE;
 716
 717     if(script_str)
 718         parse_script(script_str);
 719
 720     SysFreeString(script_str);
 721 }
 722
 723 static void run_from_res(const char *name)
 724 {
 725     const char *data;
 726     DWORD size, len;
 727     BSTR str;
 728     HRSRC src;
 729
 730     strict_dispid_check = FALSE;
 731     test_name = name;
 732
 733     src = FindResourceA(NULL, name, (LPCSTR)40);
 734     ok(src != NULL, "Could not find resource %s\n", name);
 735
 736     size = SizeofResource(NULL, src);
 737     data = LoadResource(NULL, src);
 738
 739     len = MultiByteToWideChar(CP_ACP, 0, data, size, NULL, 0);
 740     str = SysAllocStringLen(NULL, len);
 741     len = MultiByteToWideChar(CP_ACP, 0, data, size, str, len);
 742
 743     SET_EXPECT(global_success_d);
 744     SET_EXPECT(global_success_i);
 745     parse_script(str);
 746     CHECK_CALLED(global_success_d);
 747     CHECK_CALLED(global_success_i);
 748
 749     SysFreeString(str);
 750 }
 751
 752 static void test_isvisible(BOOL global_members)
 753 {
 754     IActiveScriptParse *parser;
 755     IActiveScript *engine;
 756     HRESULT hres;
 757
 758     static const WCHAR script_textW[] =
 759         {'v','a','r',' ','v',' ','=',' ','t','e','s','t','V','a','l',';',0};
 760
 761     engine = create_script();
 762     if(!engine)
 763         return;
 764
 765     hres = IActiveScript_QueryInterface(engine, &IID_IActiveScriptParse, (void**)&parser);
 766     ok(hres == S_OK, "Could not get IActiveScriptParse: %08x\n", hres);
 767     if (FAILED(hres))
 768     {
 769         IActiveScript_Release(engine);
 770         return;
 771     }
 772
 773     hres = IActiveScriptParse64_InitNew(parser);
 774     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
 775
 776     hres = IActiveScript_SetScriptSite(engine, &ActiveScriptSite);
 777     ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
 778
 779     if(global_members)
 780         SET_EXPECT(GetItemInfo_testVal);
 781     hres = IActiveScript_AddNamedItem(engine, test_valW,
 782             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|
 783             (global_members ? SCRIPTITEM_GLOBALMEMBERS : 0));
 784     ok(hres == S_OK, "AddNamedItem failed: %08x\n", hres);
 785     if(global_members)
 786         CHECK_CALLED(GetItemInfo_testVal);
 787
 788     hres = IActiveScript_SetScriptState(engine, SCRIPTSTATE_STARTED);
 789     ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_STARTED) failed: %08x\n", hres);
 790
 791     if(!global_members)
 792         SET_EXPECT(GetItemInfo_testVal);
 793     hres = IActiveScriptParse64_ParseScriptText(parser, script_textW, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 794     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 795     if(!global_members)
 796         CHECK_CALLED(GetItemInfo_testVal);
 797
 798     hres = IActiveScriptParse64_ParseScriptText(parser, script_textW, NULL, NULL, NULL, 0, 0, 0, NULL, NULL);
 799     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 800
 801     IActiveScript_Release(engine);
 802     IUnknown_Release(parser);
 803 }
 804
 805 static void run_tests(void)
 806 {
 807     HRESULT hres;
 808
 809     strict_dispid_check = TRUE;
 810
 811     parse_script_a("");
 812     parse_script_a("/* empty */ ;");
 813
 814     SET_EXPECT(global_propget_d);
 815     SET_EXPECT(global_propget_i);
 816     parse_script_a("testPropGet;");
 817     CHECK_CALLED(global_propget_d);
 818     CHECK_CALLED(global_propget_i);
 819
 820     SET_EXPECT(global_propput_d);
 821     SET_EXPECT(global_propput_i);
 822     parse_script_a("testPropPut = 1;");
 823     CHECK_CALLED(global_propput_d);
 824     CHECK_CALLED(global_propput_i);
 825
 826     SET_EXPECT(global_success_d);
 827     SET_EXPECT(global_success_i);
 828     parse_script_a("reportSuccess();");
 829     CHECK_CALLED(global_success_d);
 830     CHECK_CALLED(global_success_i);
 831
 832     SET_EXPECT(testobj_delete);
 833     parse_script_a("delete testObj.deleteTest;");
 834     CHECK_CALLED(testobj_delete);
 835
 836     parse_script_a("ok(typeof(test) === 'object', \"typeof(test) != 'object'\");");
 837
 838     run_from_res("lang.js");
 839     run_from_res("api.js");
 840     run_from_res("regexp.js");
 841
 842     test_isvisible(FALSE);
 843     test_isvisible(TRUE);
 844
 845     hres = parse_htmlscript_a("<!--");
 846     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 847     hres = parse_htmlscript_a("-->");
 848     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 849     hres = parse_htmlscript_a("<!--\nvar a=1;\n-->\n");
 850     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 851     hres = parse_htmlscript_a("<!--\n<!-- ignore this\n-->\n");
 852     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 853     hres = parse_htmlscript_a("var a=1;\nif(a-->0) a=5;\n");
 854     ok(hres == S_OK, "ParseScriptText failed: %08x\n", hres);
 855     hres = parse_htmlscript_a("var a=1;\nif(a\n-->0) a=5;\n");
 856     ok(hres != S_OK, "ParseScriptText have not failed\n");
 857 }
 858
 859 START_TEST(run)
 860 {
 861     int argc;
 862     char **argv;
 863
 864     argc = winetest_get_mainargs(&argv);
 865
 866     CoInitialize(NULL);
 867
 868     if(argc > 2)
 869         run_from_file(argv[2]);
 870     else
 871         run_tests();
 872
 873     CoUninitialize();
 874 }