git.oblomov.eu Git - wine/blob - dlls/mshtml/tests/script.c

   1 /*
   2  * Copyright 2008-2009 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 COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "dispex.h"
  30 #include "mshtml.h"
  31 #include "initguid.h"
  32 #include "activscp.h"
  33 #include "activdbg.h"
  34 #include "objsafe.h"
  35 #include "mshtmdid.h"
  36 #include "mshtml_test.h"
  37
  38 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  39
  40 #ifdef _WIN64
  41
  42 #define CTXARG_T DWORDLONG
  43 #define IActiveScriptParseVtbl IActiveScriptParse64Vtbl
  44 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_64Vtbl
  45
  46 #else
  47
  48 #define CTXARG_T DWORD
  49 #define IActiveScriptParseVtbl IActiveScriptParse32Vtbl
  50 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_32Vtbl
  51
  52 #endif
  53
  54 #define DEFINE_EXPECT(func) \
  55     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  56
  57 #define SET_EXPECT(func) \
  58     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  59
  60 #define CHECK_EXPECT2(func) \
  61     do { \
  62         ok(expect_ ##func, "unexpected call " #func "\n"); \
  63         called_ ## func = TRUE; \
  64     }while(0)
  65
  66 #define CHECK_EXPECT(func) \
  67     do { \
  68         CHECK_EXPECT2(func); \
  69         expect_ ## func = FALSE; \
  70     }while(0)
  71
  72 #define CHECK_CALLED(func) \
  73     do { \
  74         ok(called_ ## func, "expected " #func "\n"); \
  75         expect_ ## func = called_ ## func = FALSE; \
  76     }while(0)
  77
  78 #define CHECK_CALLED_BROKEN(func) \
  79     do { \
  80         ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
  81         expect_ ## func = called_ ## func = FALSE; \
  82     }while(0)
  83
  84 #define CHECK_NOT_CALLED(func) \
  85     do { \
  86         ok(!called_ ## func, "unexpected " #func "\n"); \
  87         expect_ ## func = called_ ## func = FALSE; \
  88     }while(0)
  89
  90 #define CLEAR_CALLED(func) \
  91     expect_ ## func = called_ ## func = FALSE
  92
  93
  94 DEFINE_EXPECT(CreateInstance);
  95 DEFINE_EXPECT(GetInterfaceSafetyOptions);
  96 DEFINE_EXPECT(SetInterfaceSafetyOptions);
  97 DEFINE_EXPECT(InitNew);
  98 DEFINE_EXPECT(Close);
  99 DEFINE_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
 100 DEFINE_EXPECT(SetProperty_INVOKEVERSIONING);
 101 DEFINE_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
 102 DEFINE_EXPECT(SetScriptSite);
 103 DEFINE_EXPECT(GetScriptState);
 104 DEFINE_EXPECT(SetScriptState_STARTED);
 105 DEFINE_EXPECT(SetScriptState_CONNECTED);
 106 DEFINE_EXPECT(SetScriptState_DISCONNECTED);
 107 DEFINE_EXPECT(AddNamedItem);
 108 DEFINE_EXPECT(ParseScriptText);
 109 DEFINE_EXPECT(GetScriptDispatch);
 110 DEFINE_EXPECT(funcDisp);
 111 DEFINE_EXPECT(script_testprop_d);
 112 DEFINE_EXPECT(script_testprop_i);
 113
 114 #define TESTSCRIPT_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80746}"
 115
 116 #define DISPID_SCRIPT_TESTPROP   0x100000
 117
 118 static const GUID CLSID_TestScript =
 119     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x07,0x46}};
 120
 121 static IHTMLDocument2 *notif_doc;
 122 static IDispatchEx *window_dispex;
 123 static BOOL doc_complete;
 124 static IDispatch *script_disp;
 125
 126 static const char *debugstr_guid(REFIID riid)
 127 {
 128     static char buf[50];
 129
 130     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 131             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 132             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 133             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 134
 135     return buf;
 136 }
 137
 138 static int strcmp_wa(LPCWSTR strw, const char *stra)
 139 {
 140     CHAR buf[512];
 141     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 142     return lstrcmpA(stra, buf);
 143 }
 144
 145 static BSTR a2bstr(const char *str)
 146 {
 147     BSTR ret;
 148     int len;
 149
 150     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 151     ret = SysAllocStringLen(NULL, len);
 152     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 153
 154     return ret;
 155 }
 156
 157 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 158         REFIID riid, void**ppv)
 159 {
 160     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 161         *ppv = iface;
 162         return S_OK;
 163     }
 164
 165     return E_NOINTERFACE;
 166 }
 167
 168 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 169 {
 170     return 2;
 171 }
 172
 173 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 174 {
 175     return 1;
 176 }
 177
 178 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 179 {
 180     if(dispID == DISPID_READYSTATE){
 181         BSTR state;
 182         HRESULT hres;
 183
 184         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
 185
 186         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
 187         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 188
 189         if(!lstrcmpW(state, completeW))
 190             doc_complete = TRUE;
 191
 192         SysFreeString(state);
 193     }
 194
 195     return S_OK;
 196 }
 197
 198 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 199 {
 200     ok(0, "unexpected call\n");
 201     return E_NOTIMPL;
 202 }
 203
 204 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 205     PropertyNotifySink_QueryInterface,
 206     PropertyNotifySink_AddRef,
 207     PropertyNotifySink_Release,
 208     PropertyNotifySink_OnChanged,
 209     PropertyNotifySink_OnRequestEdit
 210 };
 211
 212 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 213
 214 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 215 {
 216     *ppv = NULL;
 217
 218     if(IsEqualGUID(riid, &IID_IUnknown)
 219        || IsEqualGUID(riid, &IID_IDispatch)
 220        || IsEqualGUID(riid, &IID_IDispatchEx))
 221         *ppv = iface;
 222     else
 223         return E_NOINTERFACE;
 224
 225     return S_OK;
 226 }
 227
 228 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 229 {
 230     return 2;
 231 }
 232
 233 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 234 {
 235     return 1;
 236 }
 237
 238 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 239 {
 240     ok(0, "unexpected call\n");
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 245                                               LCID lcid, ITypeInfo **ppTInfo)
 246 {
 247     ok(0, "unexpected call\n");
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 252                                                 LPOLESTR *rgszNames, UINT cNames,
 253                                                 LCID lcid, DISPID *rgDispId)
 254 {
 255     ok(0, "unexpected call\n");
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 260                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 261                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 262 {
 263     ok(0, "unexpected call\n");
 264     return E_NOTIMPL;
 265 }
 266
 267 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 268 {
 269     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 270     return E_NOTIMPL;
 271 }
 272
 273 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 274 {
 275     ok(0, "unexpected call\n");
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 280 {
 281     ok(0, "unexpected call\n");
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 286 {
 287     ok(0, "unexpected call\n");
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 292 {
 293     ok(0, "unexpected call\n");
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 298 {
 299     ok(0, "unexpected call\n");
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 304 {
 305     ok(0, "unexpected call\n");
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI funcDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 310         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 311 {
 312     CHECK_EXPECT(funcDisp);
 313
 314     ok(id == DISPID_VALUE, "id = %d\n", id);
 315     ok(lcid == 0, "lcid = %x\n", lcid);
 316     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 317     ok(pdp != NULL, "pdp == NULL\n");
 318     ok(pdp->cArgs == 2, "pdp->cArgs = %d\n", pdp->cArgs);
 319     ok(pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 320     ok(pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 321     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 322     ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(rgvarg[1]) = %d\n", V_VT(pdp->rgvarg));
 323     ok(V_BOOL(pdp->rgvarg+1) == VARIANT_TRUE, "V_BOOL(rgvarg[1]) = %x\n", V_BOOL(pdp->rgvarg));
 324     ok(pvarRes != NULL, "pvarRes == NULL\n");
 325     ok(pei != NULL, "pei == NULL\n");
 326     ok(!pspCaller, "pspCaller != NULL\n");
 327
 328     V_VT(pvarRes) = VT_I4;
 329     V_I4(pvarRes) = 100;
 330     return S_OK;
 331 }
 332
 333 static IDispatchExVtbl testObjVtbl = {
 334     DispatchEx_QueryInterface,
 335     DispatchEx_AddRef,
 336     DispatchEx_Release,
 337     DispatchEx_GetTypeInfoCount,
 338     DispatchEx_GetTypeInfo,
 339     DispatchEx_GetIDsOfNames,
 340     DispatchEx_Invoke,
 341     DispatchEx_GetDispID,
 342     funcDisp_InvokeEx,
 343     DispatchEx_DeleteMemberByName,
 344     DispatchEx_DeleteMemberByDispID,
 345     DispatchEx_GetMemberProperties,
 346     DispatchEx_GetMemberName,
 347     DispatchEx_GetNextDispID,
 348     DispatchEx_GetNameSpaceParent
 349 };
 350
 351 static IDispatchEx funcDisp = { &testObjVtbl };
 352
 353 static HRESULT WINAPI scriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 354 {
 355     if(!strcmp_wa(bstrName, "testProp")) {
 356         CHECK_EXPECT(script_testprop_d);
 357         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 358         *pid = DISPID_SCRIPT_TESTPROP;
 359         return S_OK;
 360     }
 361
 362     ok(0, "unexpected call\n");
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI scriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 367         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 368 {
 369     switch(id) {
 370     case DISPID_SCRIPT_TESTPROP:
 371         CHECK_EXPECT(script_testprop_i);
 372
 373         ok(lcid == 0, "lcid = %x\n", lcid);
 374         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 375         ok(pdp != NULL, "pdp == NULL\n");
 376         ok(pdp->cArgs == 0, "pdp->cArgs = %d\n", pdp->cArgs);
 377         ok(pdp->cNamedArgs == 0, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 378         ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs != NULL\n");
 379         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 380         ok(pvarRes != NULL, "pvarRes == NULL\n");
 381         ok(pei != NULL, "pei == NULL\n");
 382         ok(!pspCaller, "pspCaller != NULL\n");
 383
 384         V_VT(pvarRes) = VT_NULL;
 385         break;
 386     default:
 387         ok(0, "unexpected call\n");
 388         return E_NOTIMPL;
 389     }
 390
 391     return S_OK;
 392 }
 393
 394 static IDispatchExVtbl scriptDispVtbl = {
 395     DispatchEx_QueryInterface,
 396     DispatchEx_AddRef,
 397     DispatchEx_Release,
 398     DispatchEx_GetTypeInfoCount,
 399     DispatchEx_GetTypeInfo,
 400     DispatchEx_GetIDsOfNames,
 401     DispatchEx_Invoke,
 402     scriptDisp_GetDispID,
 403     scriptDisp_InvokeEx,
 404     DispatchEx_DeleteMemberByName,
 405     DispatchEx_DeleteMemberByDispID,
 406     DispatchEx_GetMemberProperties,
 407     DispatchEx_GetMemberName,
 408     DispatchEx_GetNextDispID,
 409     DispatchEx_GetNameSpaceParent
 410 };
 411
 412 static IDispatchEx scriptDisp = { &scriptDispVtbl };
 413
 414 static IHTMLDocument2 *create_document(void)
 415 {
 416     IHTMLDocument2 *doc;
 417     HRESULT hres;
 418
 419     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 420             &IID_IHTMLDocument2, (void**)&doc);
 421     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 422
 423     return doc;
 424 }
 425
 426 static IHTMLDocument2 *create_doc_with_string(const char *str)
 427 {
 428     IPersistStreamInit *init;
 429     IStream *stream;
 430     IHTMLDocument2 *doc;
 431     HGLOBAL mem;
 432     SIZE_T len;
 433
 434     notif_doc = doc = create_document();
 435     if(!doc)
 436         return NULL;
 437
 438     doc_complete = FALSE;
 439     len = strlen(str);
 440     mem = GlobalAlloc(0, len);
 441     memcpy(mem, str, len);
 442     CreateStreamOnHGlobal(mem, TRUE, &stream);
 443
 444     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
 445
 446     IPersistStreamInit_Load(init, stream);
 447     IPersistStreamInit_Release(init);
 448     IStream_Release(stream);
 449
 450     return doc;
 451 }
 452
 453 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
 454 {
 455     IConnectionPointContainer *container;
 456     IConnectionPoint *cp;
 457     DWORD cookie;
 458     HRESULT hres;
 459
 460     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
 461     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
 462
 463     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
 464     IConnectionPointContainer_Release(container);
 465     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
 466
 467     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
 468     IConnectionPoint_Release(cp);
 469     ok(hres == S_OK, "Advise failed: %08x\n", hres);
 470 }
 471
 472 typedef void (*domtest_t)(IHTMLDocument2*);
 473
 474 static IHTMLDocument2 *create_and_load_doc(const char *str)
 475 {
 476     IHTMLDocument2 *doc;
 477     IHTMLElement *body = NULL;
 478     ULONG ref;
 479     MSG msg;
 480     HRESULT hres;
 481     static const WCHAR ucPtr[] = {'b','a','c','k','g','r','o','u','n','d',0};
 482     DISPID dispID = -1;
 483     OLECHAR *name;
 484
 485
 486     doc = create_doc_with_string(str);
 487     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
 488
 489     while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
 490         TranslateMessage(&msg);
 491         DispatchMessage(&msg);
 492     }
 493
 494     hres = IHTMLDocument2_get_body(doc, &body);
 495     ok(hres == S_OK, "get_body failed: %08x\n", hres);
 496
 497     if(!body) {
 498         skip("Could not get document body. Assuming no Gecko installed.\n");
 499         ref = IHTMLDocument2_Release(doc);
 500         ok(!ref, "ref = %d\n", ref);
 501         return NULL;
 502     }
 503
 504     /* Check we can query for function on the IHTMLElementBody interface */
 505     name = (WCHAR*)ucPtr;
 506     hres = IHTMLElement_GetIDsOfNames(body, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispID);
 507     ok(hres == S_OK, "GetIDsOfNames(background) failed %08x\n", hres);
 508     ok(dispID == DISPID_IHTMLBODYELEMENT_BACKGROUND, "Incorrect dispID got (%d)\n", dispID);
 509
 510     IHTMLElement_Release(body);
 511     return doc;
 512 }
 513
 514 static IActiveScriptSite *site;
 515 static SCRIPTSTATE state;
 516
 517 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
 518 {
 519     *ppv = NULL;
 520     ok(0, "unexpected call\n");
 521     return E_NOINTERFACE;
 522 }
 523
 524 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
 525 {
 526     return 2;
 527 }
 528
 529 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
 530 {
 531     return 1;
 532 }
 533
 534 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 535         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
 536 {
 537     CHECK_EXPECT(GetInterfaceSafetyOptions);
 538
 539     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 540     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
 541     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
 542
 543     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
 544     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
 545
 546     return S_OK;
 547 }
 548
 549 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
 550         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
 551 {
 552     CHECK_EXPECT(SetInterfaceSafetyOptions);
 553
 554     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
 555
 556     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 557        "dwOptionSetMask=%x\n", dwOptionSetMask);
 558     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
 559        "dwEnabledOptions=%x\n", dwOptionSetMask);
 560
 561     return S_OK;
 562 }
 563
 564 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
 565     ObjectSafety_QueryInterface,
 566     ObjectSafety_AddRef,
 567     ObjectSafety_Release,
 568     ObjectSafety_GetInterfaceSafetyOptions,
 569     ObjectSafety_SetInterfaceSafetyOptions
 570 };
 571
 572 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
 573
 574 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
 575 {
 576     *ppv = NULL;
 577     ok(0, "unexpected call\n");
 578     return E_NOINTERFACE;
 579 }
 580
 581 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
 582 {
 583     return 2;
 584 }
 585
 586 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
 587 {
 588     return 1;
 589 }
 590
 591 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 592         VARIANT *pvarIndex, VARIANT *pvarValue)
 593 {
 594     ok(0, "unexpected call\n");
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
 599         VARIANT *pvarIndex, VARIANT *pvarValue)
 600 {
 601     switch(dwProperty) {
 602     case SCRIPTPROP_HACK_TRIDENTEVENTSINK:
 603         CHECK_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
 604         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 605         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
 606         break;
 607     case SCRIPTPROP_INVOKEVERSIONING:
 608         CHECK_EXPECT(SetProperty_INVOKEVERSIONING);
 609         ok(V_VT(pvarValue) == VT_I4, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 610         ok(V_I4(pvarValue) == 1, "V_I4(pvarValue)=%d\n", V_I4(pvarValue));
 611         break;
 612     case SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION:
 613         CHECK_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
 614         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
 615         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
 616         break;
 617     default:
 618         ok(0, "unexpected property %x\n", dwProperty);
 619         return E_NOTIMPL;
 620     }
 621
 622     ok(!pvarIndex, "pvarIndex != NULL\n");
 623     ok(pvarValue != NULL, "pvarValue == NULL\n");
 624
 625     return S_OK;
 626 }
 627
 628 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
 629     ActiveScriptProperty_QueryInterface,
 630     ActiveScriptProperty_AddRef,
 631     ActiveScriptProperty_Release,
 632     ActiveScriptProperty_GetProperty,
 633     ActiveScriptProperty_SetProperty
 634 };
 635
 636 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
 637
 638 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
 639 {
 640     *ppv = NULL;
 641     ok(0, "unexpected call\n");
 642     return E_NOINTERFACE;
 643 }
 644
 645 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
 646 {
 647     return 2;
 648 }
 649
 650 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
 651 {
 652     return 1;
 653 }
 654
 655 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
 656         LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
 657         LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
 658         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
 659 {
 660     ok(0, "unexpected call\n");
 661     return E_NOTIMPL;
 662 }
 663
 664 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
 665     ActiveScriptParseProcedure_QueryInterface,
 666     ActiveScriptParseProcedure_AddRef,
 667     ActiveScriptParseProcedure_Release,
 668     ActiveScriptParseProcedure_ParseProcedureText
 669 };
 670
 671 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
 672
 673 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
 674 {
 675     *ppv = NULL;
 676     ok(0, "unexpected call\n");
 677     return E_NOINTERFACE;
 678 }
 679
 680 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
 681 {
 682     return 2;
 683 }
 684
 685 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
 686 {
 687     return 1;
 688 }
 689
 690 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
 691 {
 692     CHECK_EXPECT(InitNew);
 693     return S_OK;
 694 }
 695
 696 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
 697         LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
 698         LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
 699         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
 700         BSTR *pbstrName, EXCEPINFO *pexcepinfo)
 701 {
 702     ok(0, "unexpected call\n");
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT dispex_propput(IDispatchEx *obj, DISPID id, VARIANT *var)
 707 {
 708     DISPID propput_arg = DISPID_PROPERTYPUT;
 709     DISPPARAMS dp = {var, &propput_arg, 1, 1};
 710     EXCEPINFO ei = {0};
 711
 712     return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
 713 }
 714
 715 static void test_func(IDispatchEx *obj)
 716 {
 717     DISPID id;
 718     IDispatchEx *dispex;
 719     IDispatch *disp;
 720     EXCEPINFO ei;
 721     DISPPARAMS dp;
 722     BSTR str;
 723     VARIANT var;
 724     HRESULT hres;
 725
 726     str = a2bstr("toString");
 727     hres = IDispatchEx_GetDispID(obj, str, fdexNameCaseSensitive, &id);
 728     SysFreeString(str);
 729     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
 730     ok(id == DISPID_IOMNAVIGATOR_TOSTRING, "id = %x\n", id);
 731
 732     memset(&dp, 0, sizeof(dp));
 733     memset(&ei, 0, sizeof(ei));
 734     VariantInit(&var);
 735     hres = IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
 736     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 737     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
 738     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(var) == NULL\n");
 739     disp = V_DISPATCH(&var);
 740
 741     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 742     IDispatch_Release(disp);
 743     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
 744
 745     /* FIXME: Test InvokeEx(DISPATCH_METHOD) */
 746
 747     memset(&dp, 0, sizeof(dp));
 748     memset(&ei, 0, sizeof(ei));
 749     VariantInit(&var);
 750     hres = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &var, &ei, NULL);
 751     ok(hres == S_OK || broken(E_ACCESSDENIED), "InvokeEx failed: %08x\n", hres);
 752     if(SUCCEEDED(hres)) {
 753         ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
 754         ok(!strcmp_wa(V_BSTR(&var), "[object]"), "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
 755         VariantClear(&var);
 756     }
 757
 758     V_VT(&var) = VT_I4;
 759     V_I4(&var) = 100;
 760     hres = dispex_propput(obj, id, &var);
 761     ok(hres == E_NOTIMPL, "InvokeEx failed: %08x\n", hres);
 762
 763     IDispatchEx_Release(dispex);
 764 }
 765
 766 static void test_nextdispid(IDispatchEx *dispex)
 767 {
 768     DISPID last_id = DISPID_STARTENUM, id, dyn_id;
 769     BSTR name;
 770     VARIANT var;
 771     HRESULT hres;
 772
 773     name = a2bstr("dynVal");
 774     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseSensitive|fdexNameEnsure, &dyn_id);
 775     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
 776     SysFreeString(name);
 777
 778     V_VT(&var) = VT_EMPTY;
 779     hres = dispex_propput(dispex, dyn_id, &var);
 780
 781     while(last_id != dyn_id) {
 782         hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, last_id, &id);
 783         ok(hres == S_OK, "GetNextDispID returned: %08x\n", hres);
 784         ok(id != DISPID_STARTENUM, "id == DISPID_STARTENUM\n");
 785         ok(id != DISPID_IOMNAVIGATOR_TOSTRING, "id == DISPID_IOMNAVIGATOR_TOSTRING\n");
 786
 787         hres = IDispatchEx_GetMemberName(dispex, id, &name);
 788         ok(hres == S_OK, "GetMemberName failed: %08x\n", hres);
 789
 790         if(id == dyn_id)
 791             ok(!strcmp_wa(name, "dynVal"), "name = %s\n", wine_dbgstr_w(name));
 792         else if(id == DISPID_IOMNAVIGATOR_PLATFORM)
 793             ok(!strcmp_wa(name, "platform"), "name = %s\n", wine_dbgstr_w(name));
 794
 795         SysFreeString(name);
 796         last_id = id;
 797     }
 798
 799     hres = IDispatchEx_GetNextDispID(dispex, 0, id, &id);
 800     ok(hres == S_FALSE, "GetNextDispID returned: %08x\n", hres);
 801     ok(id == DISPID_STARTENUM, "id != DISPID_STARTENUM\n");
 802 }
 803
 804 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
 805         LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
 806         LPCOLESTR pstrDelimiter, CTXARG_T dwSourceContextCookie, ULONG ulStartingLine,
 807         DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
 808 {
 809     IDispatchEx *document, *dispex;
 810     IHTMLWindow2 *window;
 811     IOmNavigator *navigator;
 812     IUnknown *unk;
 813     VARIANT var, arg;
 814     DISPPARAMS dp;
 815     EXCEPINFO ei;
 816     DISPID id;
 817     BSTR tmp;
 818     HRESULT hres;
 819
 820     static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
 821     static const WCHAR testW[] = {'t','e','s','t',0};
 822     static const WCHAR funcW[] = {'f','u','n','c',0};
 823
 824     CHECK_EXPECT(ParseScriptText);
 825
 826     SET_EXPECT(GetScriptDispatch);
 827
 828     tmp = SysAllocString(documentW);
 829     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
 830     SysFreeString(tmp);
 831     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 832     ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
 833
 834     CHECK_CALLED(GetScriptDispatch);
 835
 836     VariantInit(&var);
 837     memset(&dp, 0, sizeof(dp));
 838     memset(&ei, 0, sizeof(ei));
 839
 840     hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
 841     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 842     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
 843     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
 844
 845     hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
 846     VariantClear(&var);
 847     ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
 848
 849     tmp = SysAllocString(testW);
 850     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
 851     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 852     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
 853     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
 854     SysFreeString(tmp);
 855
 856     id = 0;
 857     tmp = SysAllocString(testW);
 858     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
 859     SysFreeString(tmp);
 860     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 861     ok(id, "id == 0\n");
 862
 863     V_VT(&var) = VT_I4;
 864     V_I4(&var) = 100;
 865     hres = dispex_propput(document, id, &var);
 866     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 867
 868     tmp = SysAllocString(testW);
 869     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
 870     SysFreeString(tmp);
 871     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
 872
 873     VariantInit(&var);
 874     memset(&dp, 0, sizeof(dp));
 875     memset(&ei, 0, sizeof(ei));
 876     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
 877     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 878     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
 879     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
 880
 881     unk = (void*)0xdeadbeef;
 882     hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
 883     ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
 884     ok(!unk, "unk=%p, expected NULL\n", unk);
 885
 886     id = 0;
 887     tmp = SysAllocString(funcW);
 888     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
 889     SysFreeString(tmp);
 890     ok(hres == S_OK, "GetDispID(func) failed: %08x\n", hres);
 891     ok(id, "id == 0\n");
 892
 893     dp.cArgs = 1;
 894     dp.rgvarg = &var;
 895     dp.cNamedArgs = 0;
 896     dp.rgdispidNamedArgs = NULL;
 897     V_VT(&var) = VT_DISPATCH;
 898     V_DISPATCH(&var) = (IDispatch*)&funcDisp;
 899     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
 900     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 901
 902     VariantInit(&var);
 903     memset(&dp, 0, sizeof(dp));
 904     memset(&ei, 0, sizeof(ei));
 905     V_VT(&arg) = VT_BOOL;
 906     V_BOOL(&arg) = VARIANT_TRUE;
 907     dp.cArgs = 1;
 908     dp.rgvarg = &arg;
 909
 910     SET_EXPECT(funcDisp);
 911     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_FUNC, &dp, &var, &ei, NULL);
 912     CHECK_CALLED(funcDisp);
 913
 914     ok(hres == S_OK, "InvokeEx(INVOKE_FUNC) failed: %08x\n", hres);
 915     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
 916     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
 917
 918     IDispatchEx_Release(document);
 919
 920     hres = IDispatchEx_QueryInterface(window_dispex, &IID_IHTMLWindow2, (void**)&window);
 921     ok(hres == S_OK, "Could not get IHTMLWindow2 iface: %08x\n", hres);
 922
 923     hres = IHTMLWindow2_get_navigator(window, &navigator);
 924     IHTMLWindow2_Release(window);
 925     ok(hres == S_OK, "get_navigator failed: %08x\n", hres);
 926
 927     hres = IOmNavigator_QueryInterface(navigator, &IID_IDispatchEx, (void**)&dispex);
 928     IOmNavigator_Release(navigator);
 929     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
 930
 931     test_func(dispex);
 932     test_nextdispid(dispex);
 933     IDispatchEx_Release(dispex);
 934
 935     script_disp = (IDispatch*)&scriptDisp;
 936
 937     SET_EXPECT(GetScriptDispatch);
 938     SET_EXPECT(script_testprop_d);
 939     tmp = a2bstr("testProp");
 940     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
 941     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
 942     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
 943     CHECK_CALLED(GetScriptDispatch);
 944     CHECK_CALLED(script_testprop_d);
 945     SysFreeString(tmp);
 946
 947     tmp = a2bstr("testProp");
 948     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
 949     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
 950     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
 951     SysFreeString(tmp);
 952
 953     SET_EXPECT(GetScriptDispatch);
 954     SET_EXPECT(script_testprop_i);
 955     memset(&ei, 0, sizeof(ei));
 956     memset(&dp, 0, sizeof(dp));
 957     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
 958     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
 959     ok(V_VT(&var) == VT_NULL, "V_VT(var) = %d\n", V_VT(&var));
 960     CHECK_CALLED(GetScriptDispatch);
 961     CHECK_CALLED(script_testprop_i);
 962
 963     return S_OK;
 964 }
 965
 966 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
 967     ActiveScriptParse_QueryInterface,
 968     ActiveScriptParse_AddRef,
 969     ActiveScriptParse_Release,
 970     ActiveScriptParse_InitNew,
 971     ActiveScriptParse_AddScriptlet,
 972     ActiveScriptParse_ParseScriptText
 973 };
 974
 975 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
 976
 977 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
 978 {
 979     *ppv = NULL;
 980
 981     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
 982         *ppv = iface;
 983         return S_OK;
 984     }
 985
 986     if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
 987         *ppv = &ActiveScriptParse;
 988         return S_OK;
 989     }
 990
 991     if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
 992         *ppv = &ActiveScriptParseProcedure;
 993         return S_OK;
 994     }
 995
 996     if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
 997         *ppv = &ActiveScriptProperty;
 998         return S_OK;
 999     }
1000
1001     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
1002         *ppv = &ObjectSafety;
1003         return S_OK;
1004     }
1005
1006     if(IsEqualGUID(&IID_IActiveScriptDebug, riid))
1007         return E_NOINTERFACE;
1008
1009     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1010     return E_NOINTERFACE;
1011 }
1012
1013 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
1014 {
1015     return 2;
1016 }
1017
1018 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
1019 {
1020     return 1;
1021 }
1022
1023 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
1024 {
1025     IActiveScriptSiteInterruptPoll *poll;
1026     IActiveScriptSiteDebug *debug;
1027     IServiceProvider *service;
1028     ICanHandleException *canexpection;
1029     LCID lcid;
1030     HRESULT hres;
1031
1032     CHECK_EXPECT(SetScriptSite);
1033
1034     ok(pass != NULL, "pass == NULL\n");
1035
1036     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
1037     ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
1038     if(FAILED(hres))
1039         IActiveScriptSiteInterruptPoll_Release(poll);
1040
1041     hres = IActiveScriptSite_GetLCID(pass, &lcid);
1042     ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
1043
1044     hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
1045     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
1046
1047     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
1048     ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
1049     if(SUCCEEDED(hres))
1050         IActiveScriptSiteDebug32_Release(debug);
1051
1052     hres = IActiveScriptSite_QueryInterface(pass, &IID_ICanHandleException, (void**)&canexpection);
1053     ok(hres == E_NOINTERFACE, "Could not get IID_ICanHandleException interface: %08x\n", hres);
1054
1055     hres = IActiveScriptSite_QueryInterface(pass, &IID_IServiceProvider, (void**)&service);
1056     ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
1057     if(SUCCEEDED(hres))
1058         IServiceProvider_Release(service);
1059
1060     site = pass;
1061     IActiveScriptSite_AddRef(site);
1062     return S_OK;
1063 }
1064
1065 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
1066                                             void **ppvObject)
1067 {
1068     ok(0, "unexpected call\n");
1069     return E_NOTIMPL;
1070 }
1071
1072 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
1073 {
1074     HRESULT hres;
1075
1076     switch(ss) {
1077     case SCRIPTSTATE_STARTED:
1078         CHECK_EXPECT(SetScriptState_STARTED);
1079         break;
1080     case SCRIPTSTATE_CONNECTED:
1081         CHECK_EXPECT(SetScriptState_CONNECTED);
1082         break;
1083     case SCRIPTSTATE_DISCONNECTED:
1084         CHECK_EXPECT(SetScriptState_DISCONNECTED);
1085         break;
1086     default:
1087         ok(0, "unexpected state %d\n", ss);
1088         return E_NOTIMPL;
1089     }
1090
1091     hres = IActiveScriptSite_OnStateChange(site, (state = ss));
1092     return S_OK;
1093 }
1094
1095 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
1096 {
1097     CHECK_EXPECT(GetScriptState);
1098
1099     *pssState = state;
1100     return S_OK;
1101 }
1102
1103 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
1104 {
1105     CHECK_EXPECT(Close);
1106     return E_NOTIMPL;
1107 }
1108
1109 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
1110         LPCOLESTR pstrName, DWORD dwFlags)
1111 {
1112     IDispatch *disp;
1113     IUnknown *unk = NULL, *unk2;
1114     HRESULT hres;
1115
1116     static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
1117
1118     static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
1119
1120     CHECK_EXPECT(AddNamedItem);
1121
1122     ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", wine_dbgstr_w(pstrName));
1123     ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
1124
1125     hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
1126     ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
1127     ok(unk != NULL, "unk == NULL\n");
1128
1129     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
1130     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
1131     if(SUCCEEDED(hres))
1132         IDispatch_Release(disp);
1133
1134     hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
1135     ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
1136     if(SUCCEEDED(hres))
1137         IUnknown_Release(unk2);
1138
1139     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
1140     ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
1141
1142     IUnknown_Release(unk);
1143     return S_OK;
1144 }
1145
1146 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
1147                                          DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
1148 {
1149     ok(0, "unexpected call\n");
1150     return E_NOTIMPL;
1151 }
1152
1153 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
1154                                                 IDispatch **ppdisp)
1155 {
1156     CHECK_EXPECT(GetScriptDispatch);
1157
1158     ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
1159
1160     if(!script_disp)
1161         return E_NOTIMPL;
1162
1163     *ppdisp = script_disp;
1164     return S_OK;
1165 }
1166
1167 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
1168                                                        SCRIPTTHREADID *pstridThread)
1169 {
1170     ok(0, "unexpected call\n");
1171     return E_NOTIMPL;
1172 }
1173
1174 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
1175                                                 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
1176 {
1177     ok(0, "unexpected call\n");
1178     return E_NOTIMPL;
1179 }
1180
1181 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
1182         SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
1183 {
1184     ok(0, "unexpected call\n");
1185     return E_NOTIMPL;
1186 }
1187
1188 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
1189         SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
1190 {
1191     ok(0, "unexpected call\n");
1192     return E_NOTIMPL;
1193 }
1194
1195 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
1196 {
1197     ok(0, "unexpected call\n");
1198     return E_NOTIMPL;
1199 }
1200
1201 static const IActiveScriptVtbl ActiveScriptVtbl = {
1202     ActiveScript_QueryInterface,
1203     ActiveScript_AddRef,
1204     ActiveScript_Release,
1205     ActiveScript_SetScriptSite,
1206     ActiveScript_GetScriptSite,
1207     ActiveScript_SetScriptState,
1208     ActiveScript_GetScriptState,
1209     ActiveScript_Close,
1210     ActiveScript_AddNamedItem,
1211     ActiveScript_AddTypeLib,
1212     ActiveScript_GetScriptDispatch,
1213     ActiveScript_GetCurrentScriptThreadID,
1214     ActiveScript_GetScriptThreadID,
1215     ActiveScript_GetScriptThreadState,
1216     ActiveScript_InterruptScriptThread,
1217     ActiveScript_Clone
1218 };
1219
1220 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
1221
1222 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1223 {
1224     *ppv = NULL;
1225
1226     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1227         *ppv = iface;
1228         return S_OK;
1229     }
1230
1231     if(IsEqualGUID(&IID_IMarshal, riid))
1232         return E_NOINTERFACE;
1233     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1234         return E_NOINTERFACE;
1235
1236     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1237     return E_NOTIMPL;
1238 }
1239
1240 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1241 {
1242     return 2;
1243 }
1244
1245 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1246 {
1247     return 1;
1248 }
1249
1250 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1251 {
1252     CHECK_EXPECT(CreateInstance);
1253
1254     ok(!outer, "outer = %p\n", outer);
1255     ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", debugstr_guid(riid));
1256     *ppv = &ActiveScript;
1257     return S_OK;
1258 }
1259
1260 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1261 {
1262     ok(0, "unexpected call\n");
1263     return S_OK;
1264 }
1265
1266 static const IClassFactoryVtbl ClassFactoryVtbl = {
1267     ClassFactory_QueryInterface,
1268     ClassFactory_AddRef,
1269     ClassFactory_Release,
1270     ClassFactory_CreateInstance,
1271     ClassFactory_LockServer
1272 };
1273
1274 static IClassFactory script_cf = { &ClassFactoryVtbl };
1275
1276 static const char simple_script_str[] =
1277     "<html><head></head><body>"
1278     "<script language=\"TestScript\">simple script</script>"
1279     "</body></html>";
1280
1281 static void test_simple_script(void)
1282 {
1283     IHTMLDocument2 *doc;
1284
1285     SET_EXPECT(CreateInstance);
1286     SET_EXPECT(GetInterfaceSafetyOptions);
1287     SET_EXPECT(SetInterfaceSafetyOptions);
1288     SET_EXPECT(SetProperty_INVOKEVERSIONING); /* IE8 */
1289     SET_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
1290     SET_EXPECT(InitNew);
1291     SET_EXPECT(SetScriptSite);
1292     SET_EXPECT(GetScriptState);
1293     SET_EXPECT(SetScriptState_STARTED);
1294     SET_EXPECT(AddNamedItem);
1295     SET_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
1296     SET_EXPECT(ParseScriptText);
1297     SET_EXPECT(SetScriptState_CONNECTED);
1298
1299     doc = create_and_load_doc(simple_script_str);
1300     if(!doc) return;
1301
1302     CHECK_CALLED(CreateInstance);
1303     CHECK_CALLED(GetInterfaceSafetyOptions);
1304     CHECK_CALLED(SetInterfaceSafetyOptions);
1305     CHECK_CALLED_BROKEN(SetProperty_INVOKEVERSIONING); /* IE8 */
1306     CHECK_CALLED(SetProperty_HACK_TRIDENTEVENTSINK);
1307     CHECK_CALLED(InitNew);
1308     CHECK_CALLED(SetScriptSite);
1309     CHECK_CALLED(GetScriptState);
1310     CHECK_CALLED(SetScriptState_STARTED);
1311     CHECK_CALLED(AddNamedItem);
1312     CHECK_CALLED_BROKEN(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
1313     CHECK_CALLED(ParseScriptText);
1314     CHECK_CALLED(SetScriptState_CONNECTED);
1315
1316     if(site)
1317         IActiveScriptSite_Release(site);
1318     if(window_dispex)
1319         IDispatchEx_Release(window_dispex);
1320
1321     SET_EXPECT(SetScriptState_DISCONNECTED);
1322     SET_EXPECT(Close);
1323
1324     IHTMLDocument2_Release(doc);
1325
1326     CHECK_CALLED(SetScriptState_DISCONNECTED);
1327     CHECK_CALLED(Close);
1328 }
1329
1330 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
1331 {
1332     HKEY hkey;
1333     DWORD res;
1334
1335     if(!init) {
1336         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
1337         return TRUE;
1338     }
1339
1340     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
1341     if(res != ERROR_SUCCESS)
1342         return FALSE;
1343
1344     if(def_value)
1345         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
1346
1347     RegCloseKey(hkey);
1348
1349     return res == ERROR_SUCCESS;
1350 }
1351
1352 static BOOL init_registry(BOOL init)
1353 {
1354     return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
1355         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
1356                     NULL, init)
1357         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
1358                     NULL, init);
1359 }
1360
1361 static BOOL register_script_engine(void)
1362 {
1363     DWORD regid;
1364     HRESULT hres;
1365
1366     if(!init_registry(TRUE)) {
1367         init_registry(FALSE);
1368         return FALSE;
1369     }
1370
1371     hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
1372                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
1373     ok(hres == S_OK, "Could not register screipt engine: %08x\n", hres);
1374
1375     return TRUE;
1376 }
1377
1378 static void gecko_installer_workaround(BOOL disable)
1379 {
1380     HKEY hkey;
1381     DWORD res;
1382
1383     static BOOL has_url = FALSE;
1384     static char url[2048];
1385
1386     if(!disable && !has_url)
1387         return;
1388
1389     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
1390     if(res != ERROR_SUCCESS)
1391         return;
1392
1393     if(disable) {
1394         DWORD type, size = sizeof(url);
1395
1396         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
1397         if(res == ERROR_SUCCESS && type == REG_SZ)
1398             has_url = TRUE;
1399
1400         RegDeleteValue(hkey, "GeckoUrl");
1401     }else {
1402         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
1403     }
1404
1405     RegCloseKey(hkey);
1406 }
1407
1408 START_TEST(script)
1409 {
1410     gecko_installer_workaround(TRUE);
1411     CoInitialize(NULL);
1412
1413     if(winetest_interactive || ! is_ie_hardened()) {
1414         if(register_script_engine()) {
1415             test_simple_script();
1416             init_registry(FALSE);
1417         }else {
1418             skip("Could not register TestScript engine\n");
1419         }
1420     }else {
1421         skip("IE running in Enhanced Security Configuration\n");
1422     }
1423
1424     CoUninitialize();
1425     gecko_installer_workaround(FALSE);
1426 }