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