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