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 "wininet.h"
  30 #include "docobj.h"
  31 #include "dispex.h"
  32 #include "hlink.h"
  33 #include "mshtml.h"
  34 #include "mshtmhst.h"
  35 #include "initguid.h"
  36 #include "activscp.h"
  37 #include "activdbg.h"
  38 #include "objsafe.h"
  39 #include "mshtmdid.h"
  40 #include "mshtml_test.h"
  41
  42 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  43
  44 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */
  45 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
  46     {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
  47
  48 #ifdef _WIN64
  49
  50 #define CTXARG_T DWORDLONG
  51 #define IActiveScriptParseVtbl IActiveScriptParse64Vtbl
  52 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_64Vtbl
  53 #define IActiveScriptSiteDebug_Release IActiveScriptSiteDebug64_Release
  54
  55 #else
  56
  57 #define CTXARG_T DWORD
  58 #define IActiveScriptParseVtbl IActiveScriptParse32Vtbl
  59 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_32Vtbl
  60 #define IActiveScriptSiteDebug_Release IActiveScriptSiteDebug32_Release
  61
  62 #endif
  63
  64 #define DEFINE_EXPECT(func) \
  65     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  66
  67 #define SET_EXPECT(func) \
  68     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  69
  70 #define CHECK_EXPECT2(func) \
  71     do { \
  72         ok(expect_ ##func, "unexpected call " #func "\n"); \
  73         called_ ## func = TRUE; \
  74     }while(0)
  75
  76 #define CHECK_EXPECT(func) \
  77     do { \
  78         CHECK_EXPECT2(func); \
  79         expect_ ## func = FALSE; \
  80     }while(0)
  81
  82 #define CHECK_CALLED(func) \
  83     do { \
  84         ok(called_ ## func, "expected " #func "\n"); \
  85         expect_ ## func = called_ ## func = FALSE; \
  86     }while(0)
  87
  88 #define CHECK_CALLED_BROKEN(func) \
  89     do { \
  90         ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
  91         expect_ ## func = called_ ## func = FALSE; \
  92     }while(0)
  93
  94 #define CHECK_NOT_CALLED(func) \
  95     do { \
  96         ok(!called_ ## func, "unexpected " #func "\n"); \
  97         expect_ ## func = called_ ## func = FALSE; \
  98     }while(0)
  99
 100 #define CLEAR_CALLED(func) \
 101     expect_ ## func = called_ ## func = FALSE
 102
 103
 104 DEFINE_EXPECT(CreateInstance);
 105 DEFINE_EXPECT(GetInterfaceSafetyOptions);
 106 DEFINE_EXPECT(SetInterfaceSafetyOptions);
 107 DEFINE_EXPECT(InitNew);
 108 DEFINE_EXPECT(Close);
 109 DEFINE_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
 110 DEFINE_EXPECT(SetProperty_INVOKEVERSIONING);
 111 DEFINE_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
 112 DEFINE_EXPECT(SetScriptSite);
 113 DEFINE_EXPECT(GetScriptState);
 114 DEFINE_EXPECT(SetScriptState_STARTED);
 115 DEFINE_EXPECT(SetScriptState_CONNECTED);
 116 DEFINE_EXPECT(SetScriptState_DISCONNECTED);
 117 DEFINE_EXPECT(AddNamedItem);
 118 DEFINE_EXPECT(ParseScriptText_script);
 119 DEFINE_EXPECT(ParseScriptText_execScript);
 120 DEFINE_EXPECT(GetScriptDispatch);
 121 DEFINE_EXPECT(funcDisp);
 122 DEFINE_EXPECT(script_divid_d);
 123 DEFINE_EXPECT(script_testprop_d);
 124 DEFINE_EXPECT(script_testprop_i);
 125 DEFINE_EXPECT(script_testprop2_d);
 126 DEFINE_EXPECT(AXQueryInterface_IActiveScript);
 127 DEFINE_EXPECT(AXQueryInterface_IObjectSafety);
 128 DEFINE_EXPECT(AXGetInterfaceSafetyOptions);
 129 DEFINE_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
 130 DEFINE_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
 131 DEFINE_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
 132 DEFINE_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
 133 DEFINE_EXPECT(external_success);
 134 DEFINE_EXPECT(QS_VariantConversion);
 135 DEFINE_EXPECT(QS_IActiveScriptSite);
 136 DEFINE_EXPECT(QS_GetCaller);
 137 DEFINE_EXPECT(ChangeType);
 138 DEFINE_EXPECT(GetTypeInfo);
 139
 140 #define TESTSCRIPT_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80746}"
 141 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80646}"
 142
 143 #define DISPID_SCRIPT_TESTPROP   0x100000
 144 #define DISPID_SCRIPT_TESTPROP2  0x100001
 145
 146 #define DISPID_EXTERNAL_OK             0x300000
 147 #define DISPID_EXTERNAL_TRACE          0x300001
 148 #define DISPID_EXTERNAL_REPORTSUCCESS  0x300002
 149 #define DISPID_EXTERNAL_TODO_WINE_OK   0x300003
 150 #define DISPID_EXTERNAL_BROKEN         0x300004
 151 #define DISPID_EXTERNAL_WIN_SKIP       0x300005
 152 #define DISPID_EXTERNAL_WRITESTREAM    0x300006
 153
 154 static const GUID CLSID_TestScript =
 155     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x07,0x46}};
 156 static const GUID CLSID_TestActiveX =
 157     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
 158
 159 static BOOL is_ie9plus;
 160 static IHTMLDocument2 *notif_doc;
 161 static IOleDocumentView *view;
 162 static IDispatchEx *window_dispex;
 163 static BOOL doc_complete;
 164 static IDispatch *script_disp;
 165 static BOOL ax_objsafe;
 166 static HWND container_hwnd;
 167 static HRESULT ax_getopt_hres = S_OK, ax_setopt_dispex_hres = S_OK;
 168 static HRESULT ax_setopt_disp_caller_hres = S_OK, ax_setopt_disp_data_hres = S_OK;
 169 static BOOL skip_loadobject_tests;
 170
 171 static IActiveScriptSite *site;
 172 static SCRIPTSTATE state;
 173
 174 static int strcmp_wa(LPCWSTR strw, const char *stra)
 175 {
 176     CHAR buf[512];
 177     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 178     return lstrcmpA(stra, buf);
 179 }
 180
 181 static BSTR a2bstr(const char *str)
 182 {
 183     BSTR ret;
 184     int len;
 185
 186     if(!str)
 187         return NULL;
 188
 189     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 190     ret = SysAllocStringLen(NULL, len);
 191     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 192
 193     return ret;
 194 }
 195
 196 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 197 {
 198     HKEY hkey;
 199     DWORD res;
 200
 201     if(!init) {
 202         RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
 203         return TRUE;
 204     }
 205
 206     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 207     if(res != ERROR_SUCCESS)
 208         return FALSE;
 209
 210     if(def_value)
 211         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 212
 213     RegCloseKey(hkey);
 214
 215     return res == ERROR_SUCCESS;
 216 }
 217
 218 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 219         REFIID riid, void**ppv)
 220 {
 221     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 222         *ppv = iface;
 223         return S_OK;
 224     }
 225
 226     return E_NOINTERFACE;
 227 }
 228
 229 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 230 {
 231     return 2;
 232 }
 233
 234 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 235 {
 236     return 1;
 237 }
 238
 239 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 240 {
 241     if(dispID == DISPID_READYSTATE){
 242         BSTR state;
 243         HRESULT hres;
 244
 245         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
 246
 247         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
 248         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 249
 250         if(!lstrcmpW(state, completeW))
 251             doc_complete = TRUE;
 252
 253         SysFreeString(state);
 254     }
 255
 256     return S_OK;
 257 }
 258
 259 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 260 {
 261     ok(0, "unexpected call\n");
 262     return E_NOTIMPL;
 263 }
 264
 265 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 266     PropertyNotifySink_QueryInterface,
 267     PropertyNotifySink_AddRef,
 268     PropertyNotifySink_Release,
 269     PropertyNotifySink_OnChanged,
 270     PropertyNotifySink_OnRequestEdit
 271 };
 272
 273 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 274
 275 static HRESULT WINAPI VariantChangeType_QueryInterface(IVariantChangeType *iface, REFIID riid, void **ppv)
 276 {
 277     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
 278     *ppv = NULL;
 279     return E_NOINTERFACE;
 280 }
 281
 282 static ULONG WINAPI VariantChangeType_AddRef(IVariantChangeType *iface)
 283 {
 284     return 2;
 285 }
 286
 287 static ULONG WINAPI VariantChangeType_Release(IVariantChangeType *iface)
 288 {
 289     return 1;
 290 }
 291
 292 static HRESULT WINAPI VariantChangeType_ChangeType(IVariantChangeType *iface, VARIANT *dst, VARIANT *src, LCID lcid, VARTYPE vt)
 293 {
 294     CHECK_EXPECT(ChangeType);
 295
 296     ok(dst != NULL, "dst = NULL\n");
 297     ok(V_VT(dst) == VT_EMPTY, "V_VT(dst) = %d\n", V_VT(dst));
 298     ok(src != NULL, "src = NULL\n");
 299     ok(V_VT(src) == VT_I4, "V_VT(src) = %d\n", V_VT(src));
 300     ok(V_I4(src) == 0xf0f0f0, "V_I4(src) = %x\n", V_I4(src));
 301     ok(lcid == LOCALE_NEUTRAL, "lcid = %d\n", lcid);
 302     ok(vt == VT_BSTR, "vt = %d\n", vt);
 303
 304     V_VT(dst) = VT_BSTR;
 305     V_BSTR(dst) = a2bstr("red");
 306     return S_OK;
 307 }
 308
 309 static const IVariantChangeTypeVtbl VariantChangeTypeVtbl = {
 310     VariantChangeType_QueryInterface,
 311     VariantChangeType_AddRef,
 312     VariantChangeType_Release,
 313     VariantChangeType_ChangeType
 314 };
 315
 316 static IVariantChangeType VChangeType = { &VariantChangeTypeVtbl };
 317
 318 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 319 {
 320     ok(0, "unexpected call\n");
 321     return E_NOINTERFACE;
 322 }
 323
 324 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 325 {
 326     return 2;
 327 }
 328
 329 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 330 {
 331     return 1;
 332 }
 333
 334 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
 335         REFIID riid, void **ppv)
 336 {
 337     if(IsEqualGUID(guidService, &SID_VariantConversion)) {
 338         CHECK_EXPECT(QS_VariantConversion);
 339         ok(IsEqualGUID(riid, &IID_IVariantChangeType), "unexpected riid %s\n", wine_dbgstr_guid(riid));
 340         *ppv = &VChangeType;
 341         return S_OK;
 342     }
 343
 344     if(IsEqualGUID(guidService, &IID_IActiveScriptSite)) {
 345         CHECK_EXPECT(QS_IActiveScriptSite);
 346         ok(IsEqualGUID(riid, &IID_IOleCommandTarget), "unexpected riid %s\n", wine_dbgstr_guid(riid));
 347         return IActiveScriptSite_QueryInterface(site, riid, ppv);
 348     }
 349
 350     if(IsEqualGUID(guidService, &SID_GetCaller)) {
 351         CHECK_EXPECT(QS_GetCaller);
 352         ok(IsEqualGUID(riid, &IID_IServiceProvider), "unexpected riid %s\n", wine_dbgstr_guid(riid));
 353         *ppv = NULL;
 354         return E_NOINTERFACE;
 355     }
 356
 357     ok(0, "unexpected service %s\n", wine_dbgstr_guid(guidService));
 358     return E_NOINTERFACE;
 359 }
 360
 361 static const IServiceProviderVtbl ServiceProviderVtbl = {
 362     ServiceProvider_QueryInterface,
 363     ServiceProvider_AddRef,
 364     ServiceProvider_Release,
 365     ServiceProvider_QueryService
 366 };
 367
 368 static IServiceProvider caller_sp = { &ServiceProviderVtbl };
 369
 370 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 371 {
 372     *ppv = NULL;
 373
 374     if(IsEqualGUID(riid, &IID_IUnknown)
 375        || IsEqualGUID(riid, &IID_IDispatch)
 376        || IsEqualGUID(riid, &IID_IDispatchEx))
 377         *ppv = iface;
 378     else
 379         return E_NOINTERFACE;
 380
 381     return S_OK;
 382 }
 383
 384 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 385 {
 386     return 2;
 387 }
 388
 389 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 390 {
 391     return 1;
 392 }
 393
 394 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 395 {
 396     ok(0, "unexpected call\n");
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 401                                               LCID lcid, ITypeInfo **ppTInfo)
 402 {
 403     CHECK_EXPECT2(GetTypeInfo);
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 408                                                 LPOLESTR *rgszNames, UINT cNames,
 409                                                 LCID lcid, DISPID *rgDispId)
 410 {
 411     ok(0, "unexpected call\n");
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 416                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 417                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 418 {
 419     ok(0, "unexpected call\n");
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 424 {
 425     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 426     return E_NOTIMPL;
 427 }
 428
 429 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 430 {
 431     ok(0, "unexpected call\n");
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 436 {
 437     ok(0, "unexpected call\n");
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 442 {
 443     ok(0, "unexpected call\n");
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 448 {
 449     ok(0, "unexpected call\n");
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 454 {
 455     ok(0, "unexpected call\n");
 456     return E_NOTIMPL;
 457 }
 458
 459 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 460 {
 461     ok(0, "unexpected call\n");
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI funcDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 466         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 467 {
 468     CHECK_EXPECT(funcDisp);
 469
 470     ok(id == DISPID_VALUE, "id = %d\n", id);
 471     ok(lcid == 0, "lcid = %x\n", lcid);
 472     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 473     ok(pdp != NULL, "pdp == NULL\n");
 474     ok(pdp->cArgs == 2, "pdp->cArgs = %d\n", pdp->cArgs);
 475     ok(pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 476     ok(pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 477     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 478     ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(rgvarg[1]) = %d\n", V_VT(pdp->rgvarg));
 479     ok(V_BOOL(pdp->rgvarg+1) == VARIANT_TRUE, "V_BOOL(rgvarg[1]) = %x\n", V_BOOL(pdp->rgvarg));
 480     ok(pvarRes != NULL, "pvarRes == NULL\n");
 481     ok(pei != NULL, "pei == NULL\n");
 482     ok(!pspCaller, "pspCaller != NULL\n");
 483
 484     V_VT(pvarRes) = VT_I4;
 485     V_I4(pvarRes) = 100;
 486     return S_OK;
 487 }
 488
 489 static IDispatchExVtbl testObjVtbl = {
 490     DispatchEx_QueryInterface,
 491     DispatchEx_AddRef,
 492     DispatchEx_Release,
 493     DispatchEx_GetTypeInfoCount,
 494     DispatchEx_GetTypeInfo,
 495     DispatchEx_GetIDsOfNames,
 496     DispatchEx_Invoke,
 497     DispatchEx_GetDispID,
 498     funcDisp_InvokeEx,
 499     DispatchEx_DeleteMemberByName,
 500     DispatchEx_DeleteMemberByDispID,
 501     DispatchEx_GetMemberProperties,
 502     DispatchEx_GetMemberName,
 503     DispatchEx_GetNextDispID,
 504     DispatchEx_GetNameSpaceParent
 505 };
 506
 507 static IDispatchEx funcDisp = { &testObjVtbl };
 508
 509 static HRESULT WINAPI scriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 510 {
 511     if(!strcmp_wa(bstrName, "testProp")) {
 512         CHECK_EXPECT(script_testprop_d);
 513         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 514         *pid = DISPID_SCRIPT_TESTPROP;
 515         return S_OK;
 516     }
 517
 518     if(!strcmp_wa(bstrName, "testProp2")) {
 519         CHECK_EXPECT(script_testprop2_d);
 520         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 521         *pid = DISPID_SCRIPT_TESTPROP2;
 522         return S_OK;
 523     }
 524
 525     if(!strcmp_wa(bstrName, "divid")) {
 526         CHECK_EXPECT(script_divid_d);
 527         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 528         return E_FAIL;
 529     }
 530
 531     ok(0, "unexpected call %s\n", wine_dbgstr_w(bstrName));
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI scriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 536         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 537 {
 538     switch(id) {
 539     case DISPID_SCRIPT_TESTPROP:
 540         CHECK_EXPECT(script_testprop_i);
 541
 542         ok(lcid == 0, "lcid = %x\n", lcid);
 543         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 544         ok(pdp != NULL, "pdp == NULL\n");
 545         ok(pdp->cArgs == 0, "pdp->cArgs = %d\n", pdp->cArgs);
 546         ok(pdp->cNamedArgs == 0, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 547         ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs != NULL\n");
 548         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 549         ok(pvarRes != NULL, "pvarRes == NULL\n");
 550         ok(pei != NULL, "pei == NULL\n");
 551         ok(!pspCaller, "pspCaller != NULL\n");
 552
 553         V_VT(pvarRes) = VT_NULL;
 554         break;
 555     default:
 556         ok(0, "unexpected call\n");
 557         return E_NOTIMPL;
 558     }
 559
 560     return S_OK;
 561 }
 562
 563 static IDispatchExVtbl scriptDispVtbl = {
 564     DispatchEx_QueryInterface,
 565     DispatchEx_AddRef,
 566     DispatchEx_Release,
 567     DispatchEx_GetTypeInfoCount,
 568     DispatchEx_GetTypeInfo,
 569     DispatchEx_GetIDsOfNames,
 570     DispatchEx_Invoke,
 571     scriptDisp_GetDispID,
 572     scriptDisp_InvokeEx,
 573     DispatchEx_DeleteMemberByName,
 574     DispatchEx_DeleteMemberByDispID,
 575     DispatchEx_GetMemberProperties,
 576     DispatchEx_GetMemberName,
 577     DispatchEx_GetNextDispID,
 578     DispatchEx_GetNameSpaceParent
 579 };
 580
 581 static IDispatchEx scriptDisp = { &scriptDispVtbl };
 582
 583 static HRESULT WINAPI externalDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 584 {
 585     if(!strcmp_wa(bstrName, "ok")) {
 586         *pid = DISPID_EXTERNAL_OK;
 587         return S_OK;
 588     }
 589     if(!strcmp_wa(bstrName, "trace")) {
 590         *pid = DISPID_EXTERNAL_TRACE;
 591         return S_OK;
 592     }
 593     if(!strcmp_wa(bstrName, "reportSuccess")) {
 594         *pid = DISPID_EXTERNAL_REPORTSUCCESS;
 595         return S_OK;
 596     }
 597     if(!strcmp_wa(bstrName, "todo_wine_ok")) {
 598         *pid = DISPID_EXTERNAL_TODO_WINE_OK;
 599         return S_OK;
 600     }
 601     if(!strcmp_wa(bstrName, "broken")) {
 602         *pid = DISPID_EXTERNAL_BROKEN;
 603         return S_OK;
 604     }
 605     if(!strcmp_wa(bstrName, "win_skip")) {
 606         *pid = DISPID_EXTERNAL_WIN_SKIP;
 607         return S_OK;
 608     }
 609     if(!strcmp_wa(bstrName, "writeStream")) {
 610         *pid = DISPID_EXTERNAL_WRITESTREAM;
 611         return S_OK;
 612     }
 613
 614     ok(0, "unexpected name %s\n", wine_dbgstr_w(bstrName));
 615     return DISP_E_UNKNOWNNAME;
 616 }
 617
 618 static void stream_write(const WCHAR*,const WCHAR*);
 619
 620 static HRESULT WINAPI externalDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 621         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 622 {
 623     switch(id) {
 624     case DISPID_EXTERNAL_OK: {
 625         VARIANT *b, *m;
 626
 627         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 628         ok(pdp != NULL, "pdp == NULL\n");
 629         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 630         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 631         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 632         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 633         ok(pei != NULL, "pei == NULL\n");
 634
 635         m = pdp->rgvarg;
 636         if(V_VT(m) == (VT_BYREF|VT_VARIANT))
 637             m = V_BYREF(m);
 638         ok(V_VT(m) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 639
 640         b = pdp->rgvarg+1;
 641         if(V_VT(b) == (VT_BYREF|VT_VARIANT))
 642             b = V_BYREF(b);
 643         ok(V_VT(b) == VT_BOOL, "V_VT(b) = %d\n", V_VT(b));
 644
 645         ok(V_BOOL(b), "%s\n", wine_dbgstr_w(V_BSTR(m)));
 646         return S_OK;
 647     }
 648
 649      case DISPID_EXTERNAL_TRACE:
 650         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 651         ok(pdp != NULL, "pdp == NULL\n");
 652         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 653         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 654         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 655         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 656         ok(!pvarRes, "pvarRes != NULL\n");
 657         ok(pei != NULL, "pei == NULL\n");
 658
 659         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 660         if(V_VT(pdp->rgvarg) == VT_BSTR)
 661             trace("%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 662
 663         return S_OK;
 664
 665     case DISPID_EXTERNAL_REPORTSUCCESS:
 666         CHECK_EXPECT(external_success);
 667
 668         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 669         ok(pdp != NULL, "pdp == NULL\n");
 670         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 671         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 672         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 673         ok(!pvarRes, "pvarRes != NULL\n");
 674         ok(pei != NULL, "pei == NULL\n");
 675
 676         return S_OK;
 677
 678     case DISPID_EXTERNAL_TODO_WINE_OK:
 679         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 680         ok(pdp != NULL, "pdp == NULL\n");
 681         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 682         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 683         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 684         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 685         ok(pei != NULL, "pei == NULL\n");
 686
 687         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 688         ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg));
 689         todo_wine
 690         ok(V_BOOL(pdp->rgvarg+1), "%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 691
 692         return S_OK;
 693
 694     case DISPID_EXTERNAL_BROKEN:
 695         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 696         ok(pdp != NULL, "pdp == NULL\n");
 697         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 698         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 699         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 700         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 701         ok(pei != NULL, "pei == NULL\n");
 702
 703         ok(V_VT(pdp->rgvarg) == VT_BOOL, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 704         V_VT(pvarRes) = VT_BOOL;
 705         V_BOOL(pvarRes) = broken(V_BOOL(pdp->rgvarg)) ? VARIANT_TRUE : VARIANT_FALSE;
 706         return S_OK;
 707
 708      case DISPID_EXTERNAL_WIN_SKIP:
 709         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 710         ok(pdp != NULL, "pdp == NULL\n");
 711         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 712         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 713         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 714         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 715         ok(!pvarRes, "pvarRes != NULL\n");
 716         ok(pei != NULL, "pei == NULL\n");
 717
 718         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 719         if(V_VT(pdp->rgvarg) == VT_BSTR)
 720             win_skip("%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 721
 722         return S_OK;
 723
 724      case DISPID_EXTERNAL_WRITESTREAM:
 725         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 726         ok(pdp != NULL, "pdp == NULL\n");
 727         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 728         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 729         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 730         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 731         ok(!pvarRes, "pvarRes != NULL\n");
 732         ok(pei != NULL, "pei == NULL\n");
 733
 734         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 735         ok(V_VT(pdp->rgvarg+1) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 736
 737         stream_write(V_BSTR(pdp->rgvarg+1), V_BSTR(pdp->rgvarg));
 738         return S_OK;
 739
 740     default:
 741         ok(0, "unexpected call\n");
 742         return E_NOTIMPL;
 743     }
 744
 745     return S_OK;
 746 }
 747
 748 static IDispatchExVtbl externalDispVtbl = {
 749     DispatchEx_QueryInterface,
 750     DispatchEx_AddRef,
 751     DispatchEx_Release,
 752     DispatchEx_GetTypeInfoCount,
 753     DispatchEx_GetTypeInfo,
 754     DispatchEx_GetIDsOfNames,
 755     DispatchEx_Invoke,
 756     externalDisp_GetDispID,
 757     externalDisp_InvokeEx,
 758     DispatchEx_DeleteMemberByName,
 759     DispatchEx_DeleteMemberByDispID,
 760     DispatchEx_GetMemberProperties,
 761     DispatchEx_GetMemberName,
 762     DispatchEx_GetNextDispID,
 763     DispatchEx_GetNameSpaceParent
 764 };
 765
 766 static IDispatchEx externalDisp = { &externalDispVtbl };
 767
 768 static HRESULT QueryInterface(REFIID,void**);
 769
 770 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
 771 {
 772     return QueryInterface(riid, ppv);
 773 }
 774
 775 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
 776 {
 777     return 2;
 778 }
 779
 780 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
 781 {
 782     return 1;
 783 }
 784
 785 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
 786         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
 787 {
 788     return E_NOTIMPL;
 789 }
 790
 791 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
 792 {
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
 797         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
 798         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
 799 {
 800     return S_OK;
 801 }
 802
 803 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
 804 {
 805     return S_OK;
 806 }
 807
 808 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
 809 {
 810     return S_OK;
 811 }
 812
 813 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
 814 {
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 819 {
 820     return E_NOTIMPL;
 821 }
 822
 823 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 824 {
 825     return S_OK;
 826 }
 827
 828 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
 829         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
 830 {
 831     return E_NOTIMPL;
 832 }
 833
 834 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
 835         const GUID *pguidCmdGroup, DWORD nCmdID)
 836 {
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
 841         LPOLESTR *pchKey, DWORD dw)
 842 {
 843     return S_OK;
 844 }
 845
 846 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
 847         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
 848 {
 849     return E_NOTIMPL;
 850 }
 851
 852 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
 853 {
 854     *ppDispatch = (IDispatch*)&externalDisp;
 855     return S_OK;
 856 }
 857
 858 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
 859         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
 860 {
 861     return S_FALSE;
 862 }
 863
 864 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
 865         IDataObject **ppPORet)
 866 {
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
 871         LPOLESTR *pchKey, DWORD dw)
 872 {
 873     return E_NOTIMPL;
 874 }
 875
 876 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
 877     DocHostUIHandler_QueryInterface,
 878     DocHostUIHandler_AddRef,
 879     DocHostUIHandler_Release,
 880     DocHostUIHandler_ShowContextMenu,
 881     DocHostUIHandler_GetHostInfo,
 882     DocHostUIHandler_ShowUI,
 883     DocHostUIHandler_HideUI,
 884     DocHostUIHandler_UpdateUI,
 885     DocHostUIHandler_EnableModeless,
 886     DocHostUIHandler_OnDocWindowActivate,
 887     DocHostUIHandler_OnFrameWindowActivate,
 888     DocHostUIHandler_ResizeBorder,
 889     DocHostUIHandler_TranslateAccelerator,
 890     DocHostUIHandler_GetOptionKeyPath,
 891     DocHostUIHandler_GetDropTarget,
 892     DocHostUIHandler_GetExternal,
 893     DocHostUIHandler_TranslateUrl,
 894     DocHostUIHandler_FilterDataObject,
 895     DocHostUIHandler_GetOverrideKeyPath
 896 };
 897
 898 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
 899
 900 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 901 {
 902     return E_NOINTERFACE;
 903 }
 904
 905 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 906 {
 907     return 2;
 908 }
 909
 910 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
 911 {
 912     return 1;
 913 }
 914
 915 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 916 {
 917     return E_NOTIMPL;
 918 }
 919
 920 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 921 {
 922     return E_NOTIMPL;
 923 }
 924
 925 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 926 {
 927     return E_NOTIMPL;
 928 }
 929
 930 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
 931         LPCBORDERWIDTHS pborderwidths)
 932 {
 933     return E_NOTIMPL;
 934 }
 935
 936 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
 937         LPCBORDERWIDTHS pborderwidths)
 938 {
 939     return S_OK;
 940 }
 941
 942 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 943         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 944 {
 945     return S_OK;
 946 }
 947
 948 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 949         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 950 {
 951     return E_NOTIMPL;
 952 }
 953
 954 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 955         HOLEMENU holemenu, HWND hwndActiveObject)
 956 {
 957     ok(0, "unexpected call\n");
 958     return E_NOTIMPL;
 959 }
 960
 961 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 962 {
 963     ok(0, "unexpected call\n");
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 968 {
 969     return S_OK;
 970 }
 971
 972 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 973 {
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 978 {
 979     ok(0, "unexpected call\n");
 980     return E_NOTIMPL;
 981 }
 982
 983 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 984     InPlaceFrame_QueryInterface,
 985     InPlaceFrame_AddRef,
 986     InPlaceFrame_Release,
 987     InPlaceFrame_GetWindow,
 988     InPlaceFrame_ContextSensitiveHelp,
 989     InPlaceFrame_GetBorder,
 990     InPlaceFrame_RequestBorderSpace,
 991     InPlaceFrame_SetBorderSpace,
 992     InPlaceFrame_SetActiveObject,
 993     InPlaceFrame_InsertMenus,
 994     InPlaceFrame_SetMenu,
 995     InPlaceFrame_RemoveMenus,
 996     InPlaceFrame_SetStatusText,
 997     InPlaceFrame_EnableModeless,
 998     InPlaceFrame_TranslateAccelerator
 999 };
1000
1001 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1002
1003 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1004 {
1005     return QueryInterface(riid, ppv);
1006 }
1007
1008 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1009 {
1010     return 2;
1011 }
1012
1013 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1014 {
1015     return 1;
1016 }
1017
1018 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1019 {
1020     *phwnd = container_hwnd;
1021     return S_OK;
1022 }
1023
1024 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1025 {
1026     ok(0, "unexpected call\n");
1027     return E_NOTIMPL;
1028 }
1029
1030 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1031 {
1032     return S_OK;
1033 }
1034
1035 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1036 {
1037     return S_OK;
1038 }
1039
1040 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1041 {
1042     return S_OK;
1043 }
1044
1045 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1046         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1047         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1048 {
1049     static const RECT rect = {0,0,300,300};
1050
1051     *ppFrame = &InPlaceFrame;
1052     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceFrame;
1053     *lprcPosRect = rect;
1054     *lprcClipRect = rect;
1055
1056     ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
1057     lpFrameInfo->fMDIApp = FALSE;
1058     lpFrameInfo->hwndFrame = container_hwnd;
1059     lpFrameInfo->haccel = NULL;
1060     lpFrameInfo->cAccelEntries = 0;
1061
1062     return S_OK;
1063 }
1064
1065 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1066 {
1067     return E_NOTIMPL;
1068 }
1069
1070 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1071 {
1072     return S_OK;
1073 }
1074
1075 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1076 {
1077     return S_OK;
1078 }
1079
1080 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1081 {
1082     return E_NOTIMPL;
1083 }
1084
1085 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1086 {
1087     return E_NOTIMPL;
1088 }
1089
1090 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1091 {
1092     return E_NOTIMPL;
1093 }
1094
1095 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1096     InPlaceSite_QueryInterface,
1097     InPlaceSite_AddRef,
1098     InPlaceSite_Release,
1099     InPlaceSite_GetWindow,
1100     InPlaceSite_ContextSensitiveHelp,
1101     InPlaceSite_CanInPlaceActivate,
1102     InPlaceSite_OnInPlaceActivate,
1103     InPlaceSite_OnUIActivate,
1104     InPlaceSite_GetWindowContext,
1105     InPlaceSite_Scroll,
1106     InPlaceSite_OnUIDeactivate,
1107     InPlaceSite_OnInPlaceDeactivate,
1108     InPlaceSite_DiscardUndoState,
1109     InPlaceSite_DeactivateAndUndo,
1110     InPlaceSite_OnPosRectChange,
1111 };
1112
1113 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1114
1115 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1116 {
1117     return QueryInterface(riid, ppv);
1118 }
1119
1120 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1121 {
1122     return 2;
1123 }
1124
1125 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1126 {
1127     return 1;
1128 }
1129
1130 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1131 {
1132     ok(0, "unexpected call\n");
1133     return E_NOTIMPL;
1134 }
1135
1136 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1137         IMoniker **ppmon)
1138 {
1139     ok(0, "unexpected call\n");
1140     return E_NOTIMPL;
1141 }
1142
1143 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1144 {
1145     return E_NOTIMPL;
1146 }
1147
1148 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1149 {
1150     ok(0, "unexpected call\n");
1151     return E_NOTIMPL;
1152 }
1153
1154 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1155 {
1156     ok(0, "unexpected call\n");
1157     return E_NOTIMPL;
1158 }
1159
1160 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1161 {
1162     ok(0, "unexpected call\n");
1163     return E_NOTIMPL;
1164 }
1165
1166 static const IOleClientSiteVtbl ClientSiteVtbl = {
1167     ClientSite_QueryInterface,
1168     ClientSite_AddRef,
1169     ClientSite_Release,
1170     ClientSite_SaveObject,
1171     ClientSite_GetMoniker,
1172     ClientSite_GetContainer,
1173     ClientSite_ShowObject,
1174     ClientSite_OnShowWindow,
1175     ClientSite_RequestNewObjectLayout
1176 };
1177
1178 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1179
1180 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1181 {
1182     return QueryInterface(riid, ppv);
1183 }
1184
1185 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1186 {
1187     return 2;
1188 }
1189
1190 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1191 {
1192     return 1;
1193 }
1194
1195 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1196 {
1197     RECT rect = {0,0,300,300};
1198     IOleDocument *document;
1199     HRESULT hres;
1200
1201     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1202     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1203
1204     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1205     IOleDocument_Release(document);
1206     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1207
1208     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1209     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1210
1211     hres = IOleDocumentView_UIActivate(view, TRUE);
1212     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1213
1214     hres = IOleDocumentView_SetRect(view, &rect);
1215     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1216
1217     hres = IOleDocumentView_Show(view, TRUE);
1218     ok(hres == S_OK, "Show failed: %08x\n", hres);
1219
1220     return S_OK;
1221 }
1222
1223 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1224     DocumentSite_QueryInterface,
1225     DocumentSite_AddRef,
1226     DocumentSite_Release,
1227     DocumentSite_ActivateMe
1228 };
1229
1230 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1231
1232 static HRESULT QueryInterface(REFIID riid, void **ppv)
1233 {
1234     *ppv = NULL;
1235
1236     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1237         *ppv = &ClientSite;
1238     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1239         *ppv = &DocumentSite;
1240     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1241         *ppv = &InPlaceSite;
1242     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1243         *ppv = &DocHostUIHandler;
1244
1245     return *ppv ? S_OK : E_NOINTERFACE;
1246 }
1247
1248 static IHTMLDocument2 *create_document(void)
1249 {
1250     IHTMLDocument2 *doc;
1251     HRESULT hres;
1252
1253     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1254             &IID_IHTMLDocument2, (void**)&doc);
1255     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1256     return SUCCEEDED(hres) ? doc : NULL;
1257 }
1258
1259 static void load_string(IHTMLDocument2 *doc, const char *str)
1260 {
1261     IPersistStreamInit *init;
1262     IStream *stream;
1263     HRESULT hres;
1264     HGLOBAL mem;
1265     SIZE_T len;
1266
1267     doc_complete = FALSE;
1268     len = strlen(str);
1269     mem = GlobalAlloc(0, len);
1270     memcpy(mem, str, len);
1271     hres = CreateStreamOnHGlobal(mem, TRUE, &stream);
1272     ok(hres == S_OK, "Failed to create a stream, hr %#x.\n", hres);
1273
1274     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1275     ok(hres == S_OK, "Failed to get IPersistStreamInit, hr %#x.\n", hres);
1276
1277     IPersistStreamInit_Load(init, stream);
1278     IPersistStreamInit_Release(init);
1279     IStream_Release(stream);
1280 }
1281
1282 static void do_advise(IHTMLDocument2 *doc, REFIID riid, IUnknown *unk_advise)
1283 {
1284     IConnectionPointContainer *container;
1285     IConnectionPoint *cp;
1286     DWORD cookie;
1287     HRESULT hres;
1288
1289     hres = IHTMLDocument2_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&container);
1290     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1291
1292     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1293     IConnectionPointContainer_Release(container);
1294     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1295
1296     notif_doc = doc;
1297
1298     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1299     IConnectionPoint_Release(cp);
1300     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1301 }
1302
1303 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1304 {
1305     IOleObject *oleobj;
1306     HRESULT hres;
1307
1308     if(!set && view) {
1309         IOleDocumentView_Show(view, FALSE);
1310         IOleDocumentView_CloseView(view, 0);
1311         IOleDocumentView_SetInPlaceSite(view, NULL);
1312         IOleDocumentView_Release(view);
1313         view = NULL;
1314     }
1315
1316     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1317     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1318
1319     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1320     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1321
1322     if(set) {
1323         IHlinkTarget *hlink;
1324
1325         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1326         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1327
1328         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1329         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1330
1331         IHlinkTarget_Release(hlink);
1332     }
1333
1334     IOleObject_Release(oleobj);
1335 }
1336
1337 typedef void (*domtest_t)(IHTMLDocument2*);
1338
1339 static void load_doc(IHTMLDocument2 *doc, const char *str)
1340 {
1341     IHTMLElement *body = NULL;
1342     MSG msg;
1343     HRESULT hres;
1344     static const WCHAR ucPtr[] = {'b','a','c','k','g','r','o','u','n','d',0};
1345     DISPID dispID = -1;
1346     OLECHAR *name;
1347
1348     load_string(doc, str);
1349     do_advise(doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1350
1351     while(!doc_complete && GetMessageW(&msg, NULL, 0, 0)) {
1352         TranslateMessage(&msg);
1353         DispatchMessageW(&msg);
1354     }
1355
1356     hres = IHTMLDocument2_get_body(doc, &body);
1357     ok(hres == S_OK, "get_body failed: %08x\n", hres);
1358
1359     /* Check we can query for function on the IHTMLElementBody interface */
1360     name = (WCHAR*)ucPtr;
1361     hres = IHTMLElement_GetIDsOfNames(body, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispID);
1362     ok(hres == S_OK, "GetIDsOfNames(background) failed %08x\n", hres);
1363     ok(dispID == DISPID_IHTMLBODYELEMENT_BACKGROUND, "Incorrect dispID got (%d)\n", dispID);
1364
1365     IHTMLElement_Release(body);
1366 }
1367
1368 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1369 {
1370     *ppv = NULL;
1371     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
1372     return E_NOINTERFACE;
1373 }
1374
1375 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
1376 {
1377     return 2;
1378 }
1379
1380 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
1381 {
1382     return 1;
1383 }
1384
1385 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1386         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1387 {
1388     CHECK_EXPECT(GetInterfaceSafetyOptions);
1389
1390     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
1391     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
1392     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
1393
1394     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
1395     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
1396
1397     return S_OK;
1398 }
1399
1400 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1401         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1402 {
1403     CHECK_EXPECT(SetInterfaceSafetyOptions);
1404
1405     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
1406
1407     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
1408        "dwOptionSetMask=%x\n", dwOptionSetMask);
1409     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
1410        "dwEnabledOptions=%x\n", dwOptionSetMask);
1411
1412     return S_OK;
1413 }
1414
1415 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1416     ObjectSafety_QueryInterface,
1417     ObjectSafety_AddRef,
1418     ObjectSafety_Release,
1419     ObjectSafety_GetInterfaceSafetyOptions,
1420     ObjectSafety_SetInterfaceSafetyOptions
1421 };
1422
1423 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
1424
1425 static HRESULT WINAPI AXObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1426 {
1427     *ppv = NULL;
1428
1429     if(IsEqualGUID(&IID_IActiveScript, riid)) {
1430         CHECK_EXPECT(AXQueryInterface_IActiveScript);
1431         return E_NOINTERFACE;
1432     }
1433
1434     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
1435         CHECK_EXPECT2(AXQueryInterface_IObjectSafety);
1436         if(!ax_objsafe)
1437             return E_NOINTERFACE;
1438         *ppv = iface;
1439         return S_OK;
1440     }
1441
1442     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
1443     return E_NOINTERFACE;
1444 }
1445
1446 static HRESULT WINAPI AXObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1447         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1448 {
1449     CHECK_EXPECT(AXGetInterfaceSafetyOptions);
1450
1451     ok(IsEqualGUID(&IID_IDispatchEx, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
1452     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
1453     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
1454
1455     if(SUCCEEDED(ax_getopt_hres)) {
1456         *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
1457         *pdwEnabledOptions = INTERFACE_USES_DISPEX;
1458     }
1459
1460     return ax_getopt_hres;
1461 }
1462
1463 static HRESULT WINAPI AXObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1464         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1465 {
1466     if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1467         switch(dwEnabledOptions) {
1468         case INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACE_USES_SECURITY_MANAGER:
1469             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1470             break;
1471         case INTERFACESAFE_FOR_UNTRUSTED_CALLER:
1472             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1473             break;
1474         default:
1475             ok(0, "unexpected dwEnabledOptions %x\n", dwEnabledOptions);
1476         }
1477
1478         ok(dwOptionSetMask == dwEnabledOptions, "dwOptionSetMask=%x, expected %x\n", dwOptionSetMask, dwEnabledOptions);
1479         return ax_setopt_dispex_hres;
1480     }
1481
1482     if(IsEqualGUID(&IID_IDispatch, riid)) {
1483         HRESULT hres;
1484
1485         switch(dwEnabledOptions) {
1486         case INTERFACESAFE_FOR_UNTRUSTED_CALLER:
1487             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1488             hres = ax_setopt_disp_caller_hres;
1489             break;
1490         case INTERFACESAFE_FOR_UNTRUSTED_DATA:
1491             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1492             hres = ax_setopt_disp_data_hres;
1493             break;
1494         default:
1495             ok(0, "unexpected dwEnabledOptions %x\n", dwEnabledOptions);
1496             hres = E_FAIL;
1497         }
1498         ok(dwOptionSetMask == dwEnabledOptions, "dwOptionSetMask=%x, expected %x\n", dwOptionSetMask, dwEnabledOptions);
1499         return hres;
1500     }
1501
1502     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
1503     return E_NOINTERFACE;
1504 }
1505
1506 static const IObjectSafetyVtbl AXObjectSafetyVtbl = {
1507     AXObjectSafety_QueryInterface,
1508     ObjectSafety_AddRef,
1509     ObjectSafety_Release,
1510     AXObjectSafety_GetInterfaceSafetyOptions,
1511     AXObjectSafety_SetInterfaceSafetyOptions
1512 };
1513
1514 static IObjectSafety AXObjectSafety = { &AXObjectSafetyVtbl };
1515
1516 static BOOL set_safe_reg(BOOL safe_call, BOOL safe_data)
1517 {
1518     return init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
1519                     NULL, safe_call)
1520         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
1521                     NULL, safe_data);
1522 }
1523
1524 #define check_custom_policy(a,b,c,d) _check_custom_policy(__LINE__,a,b,c,d)
1525 static void _check_custom_policy(unsigned line, HRESULT hres, BYTE *ppolicy, DWORD policy_size, DWORD expolicy)
1526 {
1527     ok_(__FILE__,line)(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1528     ok_(__FILE__,line)(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1529     ok_(__FILE__,line)(*(DWORD*)ppolicy == expolicy, "policy = %x, expected %x\n", *(DWORD*)ppolicy, expolicy);
1530     CoTaskMemFree(ppolicy);
1531 }
1532
1533 static void test_security_reg(IInternetHostSecurityManager *sec_mgr, DWORD policy_caller, DWORD policy_load)
1534 {
1535     struct CONFIRMSAFETY cs;
1536     DWORD policy_size;
1537     BYTE *ppolicy;
1538     HRESULT hres;
1539
1540     cs.clsid = CLSID_TestActiveX;
1541     cs.pUnk = (IUnknown*)&AXObjectSafety;
1542
1543     cs.dwFlags = 0;
1544     ax_objsafe = FALSE;
1545     SET_EXPECT(AXQueryInterface_IActiveScript);
1546     SET_EXPECT(AXQueryInterface_IObjectSafety);
1547     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1548             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1549     CHECK_CALLED(AXQueryInterface_IActiveScript);
1550     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1551     check_custom_policy(hres, ppolicy, policy_size, policy_caller);
1552
1553     ax_objsafe = TRUE;
1554     SET_EXPECT(AXQueryInterface_IActiveScript);
1555     SET_EXPECT(AXQueryInterface_IObjectSafety);
1556     SET_EXPECT(AXGetInterfaceSafetyOptions);
1557     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1558     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1559             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1560     CHECK_CALLED(AXQueryInterface_IActiveScript);
1561     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1562     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1563     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1564     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1565
1566     if(skip_loadobject_tests)
1567         return;
1568
1569     cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1570     ax_objsafe = FALSE;
1571     SET_EXPECT(AXQueryInterface_IActiveScript);
1572     SET_EXPECT(AXQueryInterface_IObjectSafety);
1573     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1574             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1575     CHECK_CALLED(AXQueryInterface_IActiveScript);
1576     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1577     check_custom_policy(hres, ppolicy, policy_size, policy_load);
1578
1579     ax_objsafe = TRUE;
1580     SET_EXPECT(AXQueryInterface_IActiveScript);
1581     SET_EXPECT(AXQueryInterface_IObjectSafety);
1582     SET_EXPECT(AXGetInterfaceSafetyOptions);
1583     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1584     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1585     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1586             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1587     CHECK_CALLED(AXQueryInterface_IActiveScript);
1588     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1589     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1590     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1591     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1592     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1593 }
1594
1595 static void test_security(void)
1596 {
1597     IInternetHostSecurityManager *sec_mgr;
1598     IServiceProvider *sp;
1599     DWORD policy, policy_size;
1600     struct CONFIRMSAFETY cs;
1601     BYTE *ppolicy;
1602     HRESULT hres;
1603
1604     hres = IActiveScriptSite_QueryInterface(site, &IID_IServiceProvider, (void**)&sp);
1605     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1606
1607     hres = IServiceProvider_QueryService(sp, &SID_SInternetHostSecurityManager,
1608             &IID_IInternetHostSecurityManager, (void**)&sec_mgr);
1609     IServiceProvider_Release(sp);
1610     ok(hres == S_OK, "QueryService failed: %08x\n", hres);
1611
1612     hres = IInternetHostSecurityManager_ProcessUrlAction(sec_mgr, URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy),
1613                                                          (BYTE*)&CLSID_TestActiveX, sizeof(CLSID), 0, 0);
1614     ok(hres == S_OK, "ProcessUrlAction failed: %08x\n", hres);
1615     ok(policy == URLPOLICY_ALLOW, "policy = %x\n", policy);
1616
1617     cs.clsid = CLSID_TestActiveX;
1618     cs.pUnk = (IUnknown*)&AXObjectSafety;
1619     cs.dwFlags = 0;
1620
1621     ax_objsafe = TRUE;
1622     SET_EXPECT(AXQueryInterface_IActiveScript);
1623     SET_EXPECT(AXQueryInterface_IObjectSafety);
1624     SET_EXPECT(AXGetInterfaceSafetyOptions);
1625     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1626     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1627             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1628     CHECK_CALLED(AXQueryInterface_IActiveScript);
1629     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1630     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1631     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1632     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1633
1634     cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1635     SET_EXPECT(AXQueryInterface_IActiveScript);
1636     SET_EXPECT(AXQueryInterface_IObjectSafety);
1637     SET_EXPECT(AXGetInterfaceSafetyOptions);
1638     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1639     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1640     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1641             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1642     CHECK_CALLED(AXQueryInterface_IActiveScript);
1643     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1644     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1645     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1646     if(called_AXSetInterfaceSafetyOptions_IDispatch_data) {
1647         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1648     }else {
1649         win_skip("CONFIRMSAFETYACTION_LOADOBJECT flag not supported\n");
1650         skip_loadobject_tests = TRUE;
1651         CLEAR_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1652     }
1653     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1654
1655     cs.dwFlags = 0;
1656     ax_objsafe = FALSE;
1657     SET_EXPECT(AXQueryInterface_IActiveScript);
1658     SET_EXPECT(AXQueryInterface_IObjectSafety);
1659     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1660             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1661     CHECK_CALLED(AXQueryInterface_IActiveScript);
1662     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1663     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1664
1665     if(!skip_loadobject_tests) {
1666         cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1667         ax_objsafe = FALSE;
1668         SET_EXPECT(AXQueryInterface_IActiveScript);
1669         SET_EXPECT(AXQueryInterface_IObjectSafety);
1670         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1671                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1672         CHECK_CALLED(AXQueryInterface_IActiveScript);
1673         CHECK_CALLED(AXQueryInterface_IObjectSafety);
1674         check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1675     }
1676
1677     if(set_safe_reg(TRUE, FALSE)) {
1678         test_security_reg(sec_mgr, URLPOLICY_ALLOW, URLPOLICY_DISALLOW);
1679
1680         set_safe_reg(FALSE, TRUE);
1681         test_security_reg(sec_mgr, URLPOLICY_DISALLOW, URLPOLICY_DISALLOW);
1682
1683         set_safe_reg(TRUE, TRUE);
1684         test_security_reg(sec_mgr, URLPOLICY_ALLOW, URLPOLICY_ALLOW);
1685
1686         set_safe_reg(FALSE, FALSE);
1687     }else {
1688         skip("Could not set safety registry\n");
1689     }
1690
1691     ax_objsafe = TRUE;
1692
1693     cs.dwFlags = 0;
1694     ax_setopt_dispex_hres = E_NOINTERFACE;
1695     SET_EXPECT(AXQueryInterface_IActiveScript);
1696     SET_EXPECT(AXQueryInterface_IObjectSafety);
1697     SET_EXPECT(AXGetInterfaceSafetyOptions);
1698     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1699     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1700     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1701             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1702     CHECK_CALLED(AXQueryInterface_IActiveScript);
1703     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1704     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1705     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1706     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1707     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1708
1709     ax_setopt_dispex_hres = E_FAIL;
1710     ax_setopt_disp_caller_hres = E_NOINTERFACE;
1711     SET_EXPECT(AXQueryInterface_IActiveScript);
1712     SET_EXPECT(AXQueryInterface_IObjectSafety);
1713     SET_EXPECT(AXGetInterfaceSafetyOptions);
1714     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1715     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1716     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1717             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1718     CHECK_CALLED(AXQueryInterface_IActiveScript);
1719     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1720     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1721     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1722     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1723     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1724
1725     if(!skip_loadobject_tests) {
1726         cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1727         ax_setopt_dispex_hres = E_FAIL;
1728         ax_setopt_disp_caller_hres = E_NOINTERFACE;
1729         SET_EXPECT(AXQueryInterface_IActiveScript);
1730         SET_EXPECT(AXQueryInterface_IObjectSafety);
1731         SET_EXPECT(AXGetInterfaceSafetyOptions);
1732         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1733         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1734         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1735                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1736         CHECK_CALLED(AXQueryInterface_IActiveScript);
1737         CHECK_CALLED(AXQueryInterface_IObjectSafety);
1738         CHECK_CALLED(AXGetInterfaceSafetyOptions);
1739         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1740         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1741         check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1742     }
1743
1744     cs.dwFlags = 0;
1745     ax_setopt_dispex_hres = E_FAIL;
1746     ax_setopt_disp_caller_hres = S_OK;
1747     ax_getopt_hres = E_NOINTERFACE;
1748     SET_EXPECT(AXQueryInterface_IActiveScript);
1749     SET_EXPECT(AXQueryInterface_IObjectSafety);
1750     SET_EXPECT(AXGetInterfaceSafetyOptions);
1751     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1752     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1753     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1754             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1755     CHECK_CALLED(AXQueryInterface_IActiveScript);
1756     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1757     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1758     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1759     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1760     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1761
1762     if(!skip_loadobject_tests) {
1763         cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1764         ax_setopt_dispex_hres = E_FAIL;
1765         ax_setopt_disp_caller_hres = S_OK;
1766         ax_setopt_disp_data_hres = E_FAIL;
1767         ax_getopt_hres = E_NOINTERFACE;
1768         SET_EXPECT(AXQueryInterface_IActiveScript);
1769         SET_EXPECT(AXQueryInterface_IObjectSafety);
1770         SET_EXPECT(AXGetInterfaceSafetyOptions);
1771         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1772         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1773         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1774         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1775                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1776         CHECK_CALLED(AXQueryInterface_IActiveScript);
1777         CHECK_CALLED(AXQueryInterface_IObjectSafety);
1778         CHECK_CALLED(AXGetInterfaceSafetyOptions);
1779         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1780         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1781         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1782         check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1783     }
1784
1785     IInternetHostSecurityManager_Release(sec_mgr);
1786 }
1787
1788 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
1789 {
1790     *ppv = NULL;
1791     ok(0, "unexpected call\n");
1792     return E_NOINTERFACE;
1793 }
1794
1795 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
1796 {
1797     return 2;
1798 }
1799
1800 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
1801 {
1802     return 1;
1803 }
1804
1805 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
1806         VARIANT *pvarIndex, VARIANT *pvarValue)
1807 {
1808     ok(0, "unexpected call\n");
1809     return E_NOTIMPL;
1810 }
1811
1812 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
1813         VARIANT *pvarIndex, VARIANT *pvarValue)
1814 {
1815     switch(dwProperty) {
1816     case SCRIPTPROP_HACK_TRIDENTEVENTSINK:
1817         CHECK_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
1818         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1819         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
1820         break;
1821     case SCRIPTPROP_INVOKEVERSIONING:
1822         CHECK_EXPECT(SetProperty_INVOKEVERSIONING);
1823         ok(V_VT(pvarValue) == VT_I4, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1824         ok(V_I4(pvarValue) == 1, "V_I4(pvarValue)=%d\n", V_I4(pvarValue));
1825         break;
1826     case SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION:
1827         CHECK_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
1828         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1829         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
1830         break;
1831     case 0x70000003: /* Undocumented property set by IE10 */
1832         return E_NOTIMPL;
1833     default:
1834         ok(0, "unexpected property %x\n", dwProperty);
1835         return E_NOTIMPL;
1836     }
1837
1838     ok(!pvarIndex, "pvarIndex != NULL\n");
1839     ok(pvarValue != NULL, "pvarValue == NULL\n");
1840
1841     return S_OK;
1842 }
1843
1844 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
1845     ActiveScriptProperty_QueryInterface,
1846     ActiveScriptProperty_AddRef,
1847     ActiveScriptProperty_Release,
1848     ActiveScriptProperty_GetProperty,
1849     ActiveScriptProperty_SetProperty
1850 };
1851
1852 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
1853
1854 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
1855 {
1856     *ppv = NULL;
1857     ok(0, "unexpected call\n");
1858     return E_NOINTERFACE;
1859 }
1860
1861 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
1862 {
1863     return 2;
1864 }
1865
1866 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
1867 {
1868     return 1;
1869 }
1870
1871 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
1872         LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
1873         LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
1874         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
1875 {
1876     ok(0, "unexpected call\n");
1877     return E_NOTIMPL;
1878 }
1879
1880 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
1881     ActiveScriptParseProcedure_QueryInterface,
1882     ActiveScriptParseProcedure_AddRef,
1883     ActiveScriptParseProcedure_Release,
1884     ActiveScriptParseProcedure_ParseProcedureText
1885 };
1886
1887 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
1888
1889 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
1890 {
1891     *ppv = NULL;
1892     ok(0, "unexpected call\n");
1893     return E_NOINTERFACE;
1894 }
1895
1896 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
1897 {
1898     return 2;
1899 }
1900
1901 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
1902 {
1903     return 1;
1904 }
1905
1906 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
1907 {
1908     CHECK_EXPECT(InitNew);
1909     return S_OK;
1910 }
1911
1912 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
1913         LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
1914         LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
1915         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
1916         BSTR *pbstrName, EXCEPINFO *pexcepinfo)
1917 {
1918     ok(0, "unexpected call\n");
1919     return E_NOTIMPL;
1920 }
1921
1922 static HRESULT dispex_propput(IDispatchEx *obj, DISPID id, DWORD flags, VARIANT *var, IServiceProvider *caller_sp)
1923 {
1924     DISPID propput_arg = DISPID_PROPERTYPUT;
1925     DISPPARAMS dp = {var, &propput_arg, 1, 1};
1926     EXCEPINFO ei = {0};
1927
1928     return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT|flags, &dp, NULL, &ei, caller_sp);
1929 }
1930
1931 static HRESULT dispex_propget(IDispatchEx *obj, DISPID id, VARIANT *res, IServiceProvider *caller_sp)
1932 {
1933     DISPPARAMS dp = {NULL};
1934     EXCEPINFO ei = {0};
1935
1936     return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, res, &ei, caller_sp);
1937 }
1938
1939 static void test_func(IDispatchEx *obj)
1940 {
1941     DISPID id;
1942     IDispatchEx *dispex;
1943     IDispatch *disp;
1944     EXCEPINFO ei;
1945     DISPPARAMS dp;
1946     BSTR str;
1947     VARIANT var;
1948     HRESULT hres;
1949
1950     str = a2bstr("toString");
1951     hres = IDispatchEx_GetDispID(obj, str, fdexNameCaseSensitive, &id);
1952     SysFreeString(str);
1953     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1954     ok(id == DISPID_IOMNAVIGATOR_TOSTRING, "id = %x\n", id);
1955
1956     memset(&dp, 0, sizeof(dp));
1957     memset(&ei, 0, sizeof(ei));
1958     VariantInit(&var);
1959     hres = IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1960     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1961     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
1962     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(var) == NULL\n");
1963     disp = V_DISPATCH(&var);
1964
1965     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1966     IDispatch_Release(disp);
1967     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
1968
1969     /* FIXME: Test InvokeEx(DISPATCH_METHOD) */
1970
1971     memset(&dp, 0, sizeof(dp));
1972     memset(&ei, 0, sizeof(ei));
1973     VariantInit(&var);
1974     hres = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &var, &ei, NULL);
1975     ok(hres == S_OK || broken(hres == E_ACCESSDENIED), "InvokeEx failed: %08x\n", hres);
1976     if(SUCCEEDED(hres)) {
1977         DISPID named_args[2] = { DISPID_THIS, 0xdeadbeef };
1978         VARIANT args[2];
1979
1980         ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
1981         ok(!strcmp_wa(V_BSTR(&var), "[object]"), "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
1982         VariantClear(&var);
1983
1984         dp.rgdispidNamedArgs = named_args;
1985         dp.cNamedArgs = 2;
1986         dp.cArgs = 2;
1987         dp.rgvarg = &var;
1988         V_VT(args) = VT_DISPATCH;
1989         V_DISPATCH(args) = (IDispatch*)obj;
1990         V_VT(args+1) = VT_I4;
1991         V_I4(args+1) = 3;
1992         hres = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &var, &ei, NULL);
1993         ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1994         ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
1995         ok(!strcmp_wa(V_BSTR(&var), "[object]"), "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
1996         VariantClear(&var);
1997     }
1998
1999     V_VT(&var) = VT_I4;
2000     V_I4(&var) = 100;
2001     hres = dispex_propput(obj, id, 0, &var, NULL);
2002     todo_wine ok(hres == E_NOTIMPL, "InvokeEx failed: %08x\n", hres);
2003
2004     hres = dispex_propget(dispex, DISPID_VALUE, &var, NULL);
2005     ok(hres == E_ACCESSDENIED, "InvokeEx returned: %08x, expected E_ACCESSDENIED\n", hres);
2006     if(SUCCEEDED(hres))
2007         VariantClear(&var);
2008
2009     SET_EXPECT(QS_IActiveScriptSite);
2010     SET_EXPECT(QS_GetCaller);
2011     hres = dispex_propget(dispex, DISPID_VALUE, &var, &caller_sp);
2012     ok(hres == S_OK, "InvokeEx returned: %08x, expected S_OK\n", hres);
2013     ok(V_VT(&var) == VT_BSTR, "V_VT(var) = %d\n", V_VT(&var));
2014     ok(!strcmp_wa(V_BSTR(&var), "\nfunction toString() {\n    [native code]\n}\n"),
2015        "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
2016     VariantClear(&var);
2017     todo_wine CHECK_CALLED(QS_IActiveScriptSite);
2018     todo_wine CHECK_CALLED(QS_GetCaller);
2019
2020     IDispatchEx_Release(dispex);
2021 }
2022
2023 static void test_nextdispid(IDispatchEx *dispex)
2024 {
2025     DISPID last_id = DISPID_STARTENUM, id, dyn_id;
2026     BSTR name;
2027     VARIANT var;
2028     HRESULT hres;
2029
2030     name = a2bstr("dynVal");
2031     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseSensitive|fdexNameEnsure, &dyn_id);
2032     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2033     SysFreeString(name);
2034
2035     V_VT(&var) = VT_EMPTY;
2036     hres = dispex_propput(dispex, dyn_id, 0, &var, NULL);
2037     ok(hres == S_OK, "dispex_propput failed: %08x\n", hres);
2038
2039     while(last_id != dyn_id) {
2040         hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, last_id, &id);
2041         ok(hres == S_OK, "GetNextDispID returned: %08x\n", hres);
2042         ok(id != DISPID_STARTENUM, "id == DISPID_STARTENUM\n");
2043         ok(id != DISPID_IOMNAVIGATOR_TOSTRING, "id == DISPID_IOMNAVIGATOR_TOSTRING\n");
2044
2045         hres = IDispatchEx_GetMemberName(dispex, id, &name);
2046         ok(hres == S_OK, "GetMemberName failed: %08x\n", hres);
2047
2048         if(id == dyn_id)
2049             ok(!strcmp_wa(name, "dynVal"), "name = %s\n", wine_dbgstr_w(name));
2050         else if(id == DISPID_IOMNAVIGATOR_PLATFORM)
2051             ok(!strcmp_wa(name, "platform"), "name = %s\n", wine_dbgstr_w(name));
2052
2053         SysFreeString(name);
2054         last_id = id;
2055     }
2056
2057     hres = IDispatchEx_GetNextDispID(dispex, 0, id, &id);
2058     ok(hres == S_FALSE, "GetNextDispID returned: %08x\n", hres);
2059     ok(id == DISPID_STARTENUM, "id != DISPID_STARTENUM\n");
2060 }
2061
2062 static void test_global_id(void)
2063 {
2064     VARIANT var;
2065     DISPPARAMS dp;
2066     EXCEPINFO ei;
2067     BSTR tmp;
2068     DISPID id;
2069     HRESULT hres;
2070
2071     SET_EXPECT(GetScriptDispatch);
2072     SET_EXPECT(script_divid_d);
2073     tmp = a2bstr("divid");
2074     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2075     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2076     SysFreeString(tmp);
2077     CHECK_CALLED(GetScriptDispatch);
2078     CHECK_CALLED(script_divid_d);
2079
2080     VariantInit(&var);
2081     memset(&ei, 0, sizeof(ei));
2082     memset(&dp, 0, sizeof(dp));
2083     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
2084     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2085     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var) = %d\n", V_VT(&var));
2086     VariantClear(&var);
2087 }
2088
2089 static void test_arg_conv(IHTMLWindow2 *window)
2090 {
2091     IHTMLDocument2 *doc;
2092     IDispatchEx *dispex;
2093     IHTMLElement *elem;
2094     VARIANT v;
2095     HRESULT hres;
2096
2097     hres = IHTMLWindow2_get_document(window, &doc);
2098     ok(hres == S_OK, "get_document failed: %08x\n", hres);
2099
2100     hres = IHTMLDocument2_get_body(doc, &elem);
2101     IHTMLDocument2_Release(doc);
2102     ok(hres == S_OK, "get_body failed: %08x\n", hres);
2103
2104     hres = IHTMLElement_QueryInterface(elem, &IID_IDispatchEx, (void**)&dispex);
2105     IHTMLElement_Release(elem);
2106     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
2107
2108     SET_EXPECT(QS_VariantConversion);
2109     SET_EXPECT(ChangeType);
2110     V_VT(&v) = VT_I4;
2111     V_I4(&v) = 0xf0f0f0;
2112     hres = dispex_propput(dispex, DISPID_IHTMLBODYELEMENT_BACKGROUND, 0, &v, &caller_sp);
2113     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2114     CHECK_CALLED(QS_VariantConversion);
2115     CHECK_CALLED(ChangeType);
2116
2117     V_VT(&v) = VT_EMPTY;
2118     hres = dispex_propget(dispex, DISPID_IHTMLBODYELEMENT_BGCOLOR, &v, &caller_sp);
2119     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2120     ok(V_VT(&v) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&v));
2121     ok(!V_BSTR(&v), "V_BSTR(&var) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
2122
2123     IDispatchEx_Release(dispex);
2124 }
2125
2126 #define test_elem_disabled(a,b) _test_elem_disabled(__LINE__,a,b)
2127 static void _test_elem_disabled(unsigned line, IHTMLElement *elem, VARIANT_BOOL exb)
2128 {
2129     IHTMLElement3 *elem3;
2130     VARIANT_BOOL b = 100;
2131     HRESULT hres;
2132
2133     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLElement3, (void**)&elem3);
2134     ok_(__FILE__,line)(hres == S_OK, "Could not get IHTMLElement3 iface: %08x\n", hres);
2135
2136     hres = IHTMLElement3_get_disabled(elem3, &b);
2137     ok_(__FILE__,line)(hres == S_OK, "get_disabled failed: %08x\n", hres);
2138     ok_(__FILE__,line)(b == exb, "disabled = %x, expected %x\n", b, exb);
2139
2140     IHTMLElement3_Release(elem3);
2141 }
2142
2143 static void test_default_arg_conv(IHTMLWindow2 *window)
2144 {
2145     IHTMLDocument2 *doc;
2146     IDispatchEx *dispex;
2147     IHTMLElement *elem;
2148     VARIANT v;
2149     HRESULT hres;
2150
2151     hres = IHTMLWindow2_get_document(window, &doc);
2152     ok(hres == S_OK, "get_document failed: %08x\n", hres);
2153
2154     hres = IHTMLDocument2_get_body(doc, &elem);
2155     IHTMLDocument2_Release(doc);
2156     ok(hres == S_OK, "get_body failed: %08x\n", hres);
2157
2158     hres = IHTMLElement_QueryInterface(elem, &IID_IDispatchEx, (void**)&dispex);
2159     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
2160
2161     test_elem_disabled(elem, VARIANT_FALSE);
2162
2163     V_VT(&v) = VT_BSTR;
2164     V_BSTR(&v) = a2bstr("test");
2165     hres = dispex_propput(dispex, DISPID_IHTMLELEMENT3_DISABLED, 0, &v, NULL);
2166     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2167     SysFreeString(V_BSTR(&v));
2168
2169     test_elem_disabled(elem, VARIANT_TRUE);
2170
2171     V_VT(&v) = VT_I4;
2172     V_I4(&v) = 0;
2173     hres = dispex_propput(dispex, DISPID_IHTMLELEMENT3_DISABLED, 0, &v, NULL);
2174     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2175
2176     test_elem_disabled(elem, VARIANT_FALSE);
2177
2178     V_VT(&v) = VT_I4;
2179     V_I4(&v) = 1;
2180     hres = dispex_propput(dispex, DISPID_IHTMLELEMENT3_DISABLED, DISPATCH_PROPERTYPUTREF, &v, NULL);
2181     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2182
2183     test_elem_disabled(elem, VARIANT_TRUE);
2184
2185     IHTMLElement_Release(elem);
2186     IDispatchEx_Release(dispex);
2187 }
2188
2189 static void test_ui(void)
2190 {
2191     IActiveScriptSiteUIControl *ui_control;
2192     SCRIPTUICHANDLING uic_handling = 10;
2193     HRESULT hres;
2194
2195     hres = IActiveScriptSite_QueryInterface(site, &IID_IActiveScriptSiteUIControl, (void**)&ui_control);
2196     if(hres == E_NOINTERFACE) {
2197         win_skip("IActiveScriptSiteUIControl not supported\n");
2198         return;
2199     }
2200     ok(hres == S_OK, "Could not get IActiveScriptSiteUIControl: %08x\n", hres);
2201
2202     hres = IActiveScriptSiteUIControl_GetUIBehavior(ui_control, SCRIPTUICITEM_MSGBOX, &uic_handling);
2203     ok(hres == S_OK, "GetUIBehavior failed: %08x\n", hres);
2204     ok(uic_handling == SCRIPTUICHANDLING_ALLOW, "uic_handling = %d\n", uic_handling);
2205
2206     IActiveScriptSiteUIControl_Release(ui_control);
2207 }
2208
2209 static void test_sp(void)
2210 {
2211     IServiceProvider *sp;
2212     IUnknown *unk;
2213     HRESULT hres;
2214
2215     hres = IActiveScriptSite_QueryInterface(site, &IID_IServiceProvider, (void**)&sp);
2216     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
2217
2218     hres = IServiceProvider_QueryService(sp, &SID_SContainerDispatch, &IID_IHTMLDocument, (void**)&unk);
2219     ok(hres == S_OK, "Could not get SID_SContainerDispatch service: %08x\n", hres);
2220     IUnknown_Release(unk);
2221
2222     IServiceProvider_Release(sp);
2223 }
2224
2225 static void test_script_run(void)
2226 {
2227     IDispatchEx *document, *dispex;
2228     IHTMLWindow2 *window;
2229     IOmNavigator *navigator;
2230     IUnknown *unk;
2231     VARIANT var, arg;
2232     DISPPARAMS dp;
2233     EXCEPINFO ei;
2234     DISPID id;
2235     BSTR tmp;
2236     HRESULT hres;
2237
2238     static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
2239     static const WCHAR testW[] = {'t','e','s','t',0};
2240     static const WCHAR funcW[] = {'f','u','n','c',0};
2241
2242     SET_EXPECT(GetScriptDispatch);
2243
2244     tmp = SysAllocString(documentW);
2245     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2246     SysFreeString(tmp);
2247     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
2248     ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
2249
2250     CHECK_CALLED(GetScriptDispatch);
2251
2252     VariantInit(&var);
2253     memset(&dp, 0, sizeof(dp));
2254     memset(&ei, 0, sizeof(ei));
2255
2256     hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2257     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2258     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
2259     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
2260
2261     hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
2262     VariantClear(&var);
2263     ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
2264
2265     tmp = SysAllocString(testW);
2266     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
2267     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
2268     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
2269     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
2270     SysFreeString(tmp);
2271
2272     id = 0;
2273     tmp = SysAllocString(testW);
2274     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
2275     SysFreeString(tmp);
2276     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
2277     ok(id, "id == 0\n");
2278
2279     V_VT(&var) = VT_I4;
2280     V_I4(&var) = 100;
2281     hres = dispex_propput(document, id, 0, &var, NULL);
2282     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2283
2284     tmp = SysAllocString(testW);
2285     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
2286     SysFreeString(tmp);
2287     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
2288
2289     hres = IDispatchEx_DeleteMemberByDispID(document, id);
2290     ok(hres == E_NOTIMPL, "DeleteMemberByDispID failed = %08x\n", hres);
2291
2292     VariantInit(&var);
2293     memset(&dp, 0, sizeof(dp));
2294     memset(&ei, 0, sizeof(ei));
2295     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2296     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2297     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2298     ok(V_I4(&var) == 100, "V_I4(&var) = %d\n", V_I4(&var));
2299
2300     V_VT(&var) = VT_I4;
2301     V_I4(&var) = 200;
2302     hres = dispex_propput(document, id, DISPATCH_PROPERTYPUTREF, &var, NULL);
2303     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2304
2305     VariantInit(&var);
2306     memset(&dp, 0, sizeof(dp));
2307     memset(&ei, 0, sizeof(ei));
2308     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2309     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2310     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2311     ok(V_I4(&var) == 200, "V_I4(&var) = %d\n", V_I4(&var));
2312
2313     memset(&dp, 0, sizeof(dp));
2314     memset(&ei, 0, sizeof(ei));
2315     V_VT(&var) = VT_I4;
2316     V_I4(&var) = 300;
2317     dp.cArgs = 1;
2318     dp.rgvarg = &var;
2319     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
2320     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2321
2322     VariantInit(&var);
2323     memset(&dp, 0, sizeof(dp));
2324     memset(&ei, 0, sizeof(ei));
2325     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2326     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2327     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2328     ok(V_I4(&var) == 300, "V_I4(&var) = %d\n", V_I4(&var));
2329
2330     V_VT(&var) = VT_BSTR;
2331     V_BSTR(&var) = NULL;
2332     hres = dispex_propput(document, id, 0, &var, NULL);
2333     ok(hres == S_OK, "dispex_propput failed: %08x\n", hres);
2334
2335     VariantInit(&var);
2336     memset(&dp, 0, sizeof(dp));
2337     memset(&ei, 0, sizeof(ei));
2338     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2339     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2340     ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
2341     ok(!V_BSTR(&var), "V_BSTR(&var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
2342
2343     unk = (void*)0xdeadbeef;
2344     hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
2345     ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
2346     ok(!unk, "unk=%p, expected NULL\n", unk);
2347
2348     id = 0;
2349     tmp = SysAllocString(funcW);
2350     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
2351     SysFreeString(tmp);
2352     ok(hres == S_OK, "GetDispID(func) failed: %08x\n", hres);
2353     ok(id, "id == 0\n");
2354
2355     dp.cArgs = 1;
2356     dp.rgvarg = &var;
2357     dp.cNamedArgs = 0;
2358     dp.rgdispidNamedArgs = NULL;
2359     V_VT(&var) = VT_DISPATCH;
2360     V_DISPATCH(&var) = (IDispatch*)&funcDisp;
2361     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
2362     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2363
2364     VariantInit(&var);
2365     memset(&dp, 0, sizeof(dp));
2366     memset(&ei, 0, sizeof(ei));
2367     V_VT(&arg) = VT_BOOL;
2368     V_BOOL(&arg) = VARIANT_TRUE;
2369     dp.cArgs = 1;
2370     dp.rgvarg = &arg;
2371
2372     SET_EXPECT(funcDisp);
2373     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_FUNC, &dp, &var, &ei, NULL);
2374     CHECK_CALLED(funcDisp);
2375
2376     ok(hres == S_OK, "InvokeEx(INVOKE_FUNC) failed: %08x\n", hres);
2377     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2378     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
2379
2380     IDispatchEx_Release(document);
2381
2382     hres = IDispatchEx_QueryInterface(window_dispex, &IID_IHTMLWindow2, (void**)&window);
2383     ok(hres == S_OK, "Could not get IHTMLWindow2 iface: %08x\n", hres);
2384
2385     hres = IHTMLWindow2_get_navigator(window, &navigator);
2386     ok(hres == S_OK, "get_navigator failed: %08x\n", hres);
2387
2388     hres = IOmNavigator_QueryInterface(navigator, &IID_IDispatchEx, (void**)&dispex);
2389     IOmNavigator_Release(navigator);
2390     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
2391
2392     test_func(dispex);
2393     test_nextdispid(dispex);
2394
2395     test_arg_conv(window);
2396     test_default_arg_conv(window);
2397     IHTMLWindow2_Release(window);
2398
2399     tmp = a2bstr("test");
2400     hres = IDispatchEx_DeleteMemberByName(dispex, tmp, fdexNameCaseSensitive);
2401     ok(hres == E_NOTIMPL, "DeleteMemberByName failed: %08x\n", hres);
2402
2403     IDispatchEx_Release(dispex);
2404
2405     script_disp = (IDispatch*)&scriptDisp;
2406
2407     SET_EXPECT(GetScriptDispatch);
2408     SET_EXPECT(script_testprop_d);
2409     tmp = a2bstr("testProp");
2410     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2411     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2412     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
2413     CHECK_CALLED(GetScriptDispatch);
2414     CHECK_CALLED(script_testprop_d);
2415     SysFreeString(tmp);
2416
2417     tmp = a2bstr("testProp");
2418     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2419     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2420     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
2421     SysFreeString(tmp);
2422
2423     SET_EXPECT(GetScriptDispatch);
2424     SET_EXPECT(script_testprop_i);
2425     memset(&ei, 0, sizeof(ei));
2426     memset(&dp, 0, sizeof(dp));
2427     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
2428     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2429     ok(V_VT(&var) == VT_NULL, "V_VT(var) = %d\n", V_VT(&var));
2430     CHECK_CALLED(GetScriptDispatch);
2431     CHECK_CALLED(script_testprop_i);
2432
2433     SET_EXPECT(GetScriptDispatch);
2434     SET_EXPECT(script_testprop2_d);
2435     tmp = a2bstr("testProp2");
2436     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
2437     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2438     ok(id != DISPID_SCRIPT_TESTPROP2, "id == DISPID_SCRIPT_TESTPROP2\n");
2439     CHECK_CALLED(GetScriptDispatch);
2440     CHECK_CALLED(script_testprop2_d);
2441     SysFreeString(tmp);
2442
2443     tmp = a2bstr("test");
2444     hres = IDispatchEx_DeleteMemberByName(window_dispex, tmp, fdexNameCaseSensitive);
2445     ok(hres == E_NOTIMPL, "DeleteMemberByName failed: %08x\n", hres);
2446
2447     test_global_id();
2448
2449     test_security();
2450     test_ui();
2451     test_sp();
2452 }
2453
2454 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
2455         LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
2456         LPCOLESTR pstrDelimiter, CTXARG_T dwSourceContextCookie, ULONG ulStartingLine,
2457         DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
2458 {
2459     ok(pvarResult != NULL, "pvarResult == NULL\n");
2460     ok(pexcepinfo != NULL, "pexcepinfo == NULL\n");
2461
2462     if(!strcmp_wa(pstrCode, "execScript call")) {
2463         CHECK_EXPECT(ParseScriptText_execScript);
2464         ok(!pstrItemName, "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2465         ok(!strcmp_wa(pstrDelimiter, "\""), "pstrDelimiter = %s\n", wine_dbgstr_w(pstrDelimiter));
2466         ok(dwFlags == SCRIPTTEXT_ISVISIBLE, "dwFlags = %x\n", dwFlags);
2467
2468         V_VT(pvarResult) = VT_I4;
2469         V_I4(pvarResult) = 10;
2470         return S_OK;
2471     }else if(!strcmp_wa(pstrCode, "simple script")) {
2472         CHECK_EXPECT(ParseScriptText_script);
2473         ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2474         ok(!strcmp_wa(pstrDelimiter, "</SCRIPT>"), "pstrDelimiter = %s\n", wine_dbgstr_w(pstrDelimiter));
2475         ok(dwFlags == (SCRIPTTEXT_ISVISIBLE|SCRIPTTEXT_HOSTMANAGESSOURCE), "dwFlags = %x\n", dwFlags);
2476
2477         test_script_run();
2478         return S_OK;
2479     }
2480
2481     ok(0, "unexpected script %s\n", wine_dbgstr_w(pstrCode));
2482     return E_FAIL;
2483 }
2484
2485 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
2486     ActiveScriptParse_QueryInterface,
2487     ActiveScriptParse_AddRef,
2488     ActiveScriptParse_Release,
2489     ActiveScriptParse_InitNew,
2490     ActiveScriptParse_AddScriptlet,
2491     ActiveScriptParse_ParseScriptText
2492 };
2493
2494 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
2495
2496 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
2497 {
2498     *ppv = NULL;
2499
2500     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
2501         *ppv = iface;
2502         return S_OK;
2503     }
2504
2505     if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
2506         *ppv = &ActiveScriptParse;
2507         return S_OK;
2508     }
2509
2510     if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
2511         *ppv = &ActiveScriptParseProcedure;
2512         return S_OK;
2513     }
2514
2515     if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
2516         *ppv = &ActiveScriptProperty;
2517         return S_OK;
2518     }
2519
2520     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
2521         *ppv = &ObjectSafety;
2522         return S_OK;
2523     }
2524
2525     if(IsEqualGUID(&IID_IActiveScriptDebug, riid))
2526         return E_NOINTERFACE;
2527
2528     trace("QI(%s)\n", wine_dbgstr_guid(riid));
2529     return E_NOINTERFACE;
2530 }
2531
2532 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
2533 {
2534     return 2;
2535 }
2536
2537 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
2538 {
2539     return 1;
2540 }
2541
2542 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
2543 {
2544     IActiveScriptSiteInterruptPoll *poll;
2545     IActiveScriptSiteDebug *debug;
2546     IServiceProvider *service;
2547     ICanHandleException *canexpection;
2548     LCID lcid;
2549     HRESULT hres;
2550
2551     CHECK_EXPECT(SetScriptSite);
2552
2553     ok(pass != NULL, "pass == NULL\n");
2554
2555     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
2556     ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
2557     if(SUCCEEDED(hres))
2558         IActiveScriptSiteInterruptPoll_Release(poll);
2559
2560     hres = IActiveScriptSite_GetLCID(pass, &lcid);
2561     ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
2562
2563     hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
2564     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
2565
2566     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
2567     ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
2568     if(SUCCEEDED(hres))
2569         IActiveScriptSiteDebug_Release(debug);
2570
2571     hres = IActiveScriptSite_QueryInterface(pass, &IID_ICanHandleException, (void**)&canexpection);
2572     ok(hres == E_NOINTERFACE, "Could not get IID_ICanHandleException interface: %08x\n", hres);
2573
2574     hres = IActiveScriptSite_QueryInterface(pass, &IID_IServiceProvider, (void**)&service);
2575     ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
2576     if(SUCCEEDED(hres))
2577         IServiceProvider_Release(service);
2578
2579     site = pass;
2580     IActiveScriptSite_AddRef(site);
2581     return S_OK;
2582 }
2583
2584 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
2585                                             void **ppvObject)
2586 {
2587     ok(0, "unexpected call\n");
2588     return E_NOTIMPL;
2589 }
2590
2591 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
2592 {
2593     HRESULT hres;
2594
2595     switch(ss) {
2596     case SCRIPTSTATE_STARTED:
2597         CHECK_EXPECT(SetScriptState_STARTED);
2598         break;
2599     case SCRIPTSTATE_CONNECTED:
2600         CHECK_EXPECT(SetScriptState_CONNECTED);
2601         break;
2602     case SCRIPTSTATE_DISCONNECTED:
2603         CHECK_EXPECT(SetScriptState_DISCONNECTED);
2604         break;
2605     default:
2606         ok(0, "unexpected state %d\n", ss);
2607         return E_NOTIMPL;
2608     }
2609
2610     hres = IActiveScriptSite_OnStateChange(site, (state = ss));
2611     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
2612
2613     return S_OK;
2614 }
2615
2616 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
2617 {
2618     CHECK_EXPECT(GetScriptState);
2619
2620     *pssState = state;
2621     return S_OK;
2622 }
2623
2624 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
2625 {
2626     CHECK_EXPECT(Close);
2627     return E_NOTIMPL;
2628 }
2629
2630 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
2631         LPCOLESTR pstrName, DWORD dwFlags)
2632 {
2633     IDispatch *disp;
2634     IUnknown *unk = NULL, *unk2;
2635     HRESULT hres;
2636
2637     static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
2638
2639     static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
2640
2641     CHECK_EXPECT(AddNamedItem);
2642
2643     ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", wine_dbgstr_w(pstrName));
2644     ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
2645
2646     hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
2647     ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
2648     ok(unk != NULL, "unk == NULL\n");
2649
2650     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2651     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
2652     if(SUCCEEDED(hres))
2653         IDispatch_Release(disp);
2654
2655     hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
2656     ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
2657     if(SUCCEEDED(hres))
2658         IUnknown_Release(unk2);
2659
2660     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
2661     ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
2662
2663     IUnknown_Release(unk);
2664     return S_OK;
2665 }
2666
2667 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
2668                                          DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
2669 {
2670     ok(0, "unexpected call\n");
2671     return E_NOTIMPL;
2672 }
2673
2674 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
2675                                                 IDispatch **ppdisp)
2676 {
2677     CHECK_EXPECT(GetScriptDispatch);
2678
2679     ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2680
2681     if(!script_disp)
2682         return E_NOTIMPL;
2683
2684     *ppdisp = script_disp;
2685     return S_OK;
2686 }
2687
2688 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
2689                                                        SCRIPTTHREADID *pstridThread)
2690 {
2691     ok(0, "unexpected call\n");
2692     return E_NOTIMPL;
2693 }
2694
2695 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
2696                                                 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
2697 {
2698     ok(0, "unexpected call\n");
2699     return E_NOTIMPL;
2700 }
2701
2702 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
2703         SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
2704 {
2705     ok(0, "unexpected call\n");
2706     return E_NOTIMPL;
2707 }
2708
2709 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
2710         SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
2711 {
2712     ok(0, "unexpected call\n");
2713     return E_NOTIMPL;
2714 }
2715
2716 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
2717 {
2718     ok(0, "unexpected call\n");
2719     return E_NOTIMPL;
2720 }
2721
2722 static const IActiveScriptVtbl ActiveScriptVtbl = {
2723     ActiveScript_QueryInterface,
2724     ActiveScript_AddRef,
2725     ActiveScript_Release,
2726     ActiveScript_SetScriptSite,
2727     ActiveScript_GetScriptSite,
2728     ActiveScript_SetScriptState,
2729     ActiveScript_GetScriptState,
2730     ActiveScript_Close,
2731     ActiveScript_AddNamedItem,
2732     ActiveScript_AddTypeLib,
2733     ActiveScript_GetScriptDispatch,
2734     ActiveScript_GetCurrentScriptThreadID,
2735     ActiveScript_GetScriptThreadID,
2736     ActiveScript_GetScriptThreadState,
2737     ActiveScript_InterruptScriptThread,
2738     ActiveScript_Clone
2739 };
2740
2741 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
2742
2743 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2744 {
2745     *ppv = NULL;
2746
2747     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
2748         *ppv = iface;
2749         return S_OK;
2750     }
2751
2752     if(IsEqualGUID(&IID_IMarshal, riid))
2753         return E_NOINTERFACE;
2754     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
2755         return E_NOINTERFACE;
2756
2757     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
2758     return E_NOTIMPL;
2759 }
2760
2761 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
2762 {
2763     return 2;
2764 }
2765
2766 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
2767 {
2768     return 1;
2769 }
2770
2771 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2772 {
2773     CHECK_EXPECT(CreateInstance);
2774
2775     ok(!outer, "outer = %p\n", outer);
2776     ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
2777     *ppv = &ActiveScript;
2778     return S_OK;
2779 }
2780
2781 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
2782 {
2783     ok(0, "unexpected call\n");
2784     return S_OK;
2785 }
2786
2787 static const IClassFactoryVtbl ClassFactoryVtbl = {
2788     ClassFactory_QueryInterface,
2789     ClassFactory_AddRef,
2790     ClassFactory_Release,
2791     ClassFactory_CreateInstance,
2792     ClassFactory_LockServer
2793 };
2794
2795 static IClassFactory script_cf = { &ClassFactoryVtbl };
2796
2797 typedef struct {
2798     IInternetProtocolEx IInternetProtocolEx_iface;
2799     IWinInetHttpInfo IWinInetHttpInfo_iface;
2800
2801     LONG ref;
2802
2803     IInternetProtocolSink *sink;
2804     BINDINFO bind_info;
2805
2806     IStream *stream;
2807     char *data;
2808     size_t size;
2809     char *ptr;
2810
2811     IUri *uri;
2812 } ProtocolHandler;
2813
2814 static void report_data(ProtocolHandler *This)
2815 {
2816     IServiceProvider *service_provider;
2817     IHttpNegotiate *http_negotiate;
2818     WCHAR *addl_headers = NULL;
2819     BSTR headers, url;
2820     HRESULT hres;
2821
2822     static const WCHAR emptyW[] = {0};
2823
2824     hres = IInternetProtocolSink_QueryInterface(This->sink, &IID_IServiceProvider, (void**)&service_provider);
2825     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
2826
2827     hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate, &IID_IHttpNegotiate, (void**)&http_negotiate);
2828     IServiceProvider_Release(service_provider);
2829     ok(hres == S_OK, "Could not get IHttpNegotiate interface: %08x\n", hres);
2830
2831     hres = IUri_GetDisplayUri(This->uri, &url);
2832     ok(hres == S_OK, "Failed to get display uri: %08x\n", hres);
2833     hres = IHttpNegotiate_BeginningTransaction(http_negotiate, url, emptyW, 0, &addl_headers);
2834     ok(hres == S_OK, "BeginningTransaction failed: %08x\n", hres);
2835     SysFreeString(url);
2836
2837     CoTaskMemFree(addl_headers);
2838
2839     headers = a2bstr("HTTP/1.1 200 OK\r\n\r\n");
2840     hres = IHttpNegotiate_OnResponse(http_negotiate, 200, headers, NULL, NULL);
2841     ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
2842     SysFreeString(headers);
2843
2844     IHttpNegotiate_Release(http_negotiate);
2845
2846     hres = IInternetProtocolSink_ReportData(This->sink, BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION,
2847                                             This->size, This->size);
2848     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
2849
2850     hres = IInternetProtocolSink_ReportResult(This->sink, S_OK, 0, NULL);
2851     ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
2852 }
2853
2854 typedef struct js_stream_t {
2855     struct js_stream_t *next;
2856     ProtocolHandler *protocol_handler;
2857     WCHAR name[1];
2858 } js_stream_t;
2859
2860 static js_stream_t *registered_stream_list;
2861
2862 static void register_stream(ProtocolHandler *protocol_handler, const WCHAR *name)
2863 {
2864     js_stream_t *stream;
2865     size_t len;
2866
2867     len = lstrlenW(name)+1;
2868     stream = HeapAlloc(GetProcessHeap(), 0, offsetof(js_stream_t, name[len+1]));
2869
2870     IInternetProtocolEx_AddRef(&protocol_handler->IInternetProtocolEx_iface);
2871     stream->protocol_handler = protocol_handler;
2872     memcpy(stream->name, name, len*sizeof(WCHAR));
2873
2874     stream->next = registered_stream_list;
2875     registered_stream_list = stream;
2876 }
2877
2878 static void free_registered_streams(void)
2879 {
2880     js_stream_t *iter;
2881
2882     while((iter = registered_stream_list)) {
2883         ok(!iter->protocol_handler, "protocol handler still pending for %s\n", wine_dbgstr_w(iter->name));
2884         if(iter->protocol_handler)
2885             IInternetProtocolEx_Release(&iter->protocol_handler->IInternetProtocolEx_iface);
2886
2887         registered_stream_list = iter->next;
2888         HeapFree(GetProcessHeap(), 0, iter);
2889     }
2890 }
2891
2892 static DWORD WINAPI async_switch_proc(void *arg)
2893 {
2894     PROTOCOLDATA protocol_data = {PI_FORCE_ASYNC};
2895     ProtocolHandler *protocol_handler = arg;
2896
2897     IInternetProtocolSink_Switch(protocol_handler->sink, &protocol_data);
2898     return 0;
2899 }
2900
2901 static void async_switch(ProtocolHandler *protocol_handler)
2902 {
2903     IInternetProtocolEx_AddRef(&protocol_handler->IInternetProtocolEx_iface);
2904     QueueUserWorkItem(async_switch_proc, protocol_handler, 0);
2905 }
2906
2907 static void stream_write(const WCHAR *name, const WCHAR *data)
2908 {
2909     ProtocolHandler *protocol_handler;
2910     LARGE_INTEGER large_zero;
2911     js_stream_t *stream;
2912     HRESULT hres;
2913
2914     static const BYTE bom_utf16[] = {0xff,0xfe};
2915
2916     for(stream = registered_stream_list; stream; stream = stream->next) {
2917         if(!lstrcmpW(stream->name, name))
2918             break;
2919     }
2920     ok(stream != NULL, "stream %s not found\n", wine_dbgstr_w(name));
2921     if(!stream)
2922         return;
2923
2924     protocol_handler = stream->protocol_handler;
2925     ok(protocol_handler != NULL, "protocol_handler is NULL\n");
2926     if(!protocol_handler)
2927         return;
2928     stream->protocol_handler = NULL;
2929
2930     hres = CreateStreamOnHGlobal(NULL, TRUE, &protocol_handler->stream);
2931     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
2932
2933     hres = IStream_Write(protocol_handler->stream, bom_utf16, sizeof(bom_utf16), NULL);
2934     ok(hres == S_OK, "Write failed: %08x\n", hres);
2935
2936     hres = IStream_Write(protocol_handler->stream, data, lstrlenW(data)*sizeof(WCHAR), NULL);
2937     ok(hres == S_OK, "Write failed: %08x\n", hres);
2938
2939     U(large_zero).QuadPart = 0;
2940     hres = IStream_Seek(protocol_handler->stream, large_zero, STREAM_SEEK_SET, NULL);
2941     ok(hres == S_OK, "Seek failed: %08x\n", hres);
2942
2943     async_switch(protocol_handler);
2944     IInternetProtocolEx_Release(&protocol_handler->IInternetProtocolEx_iface);
2945 }
2946
2947 static char index_html_data[4096];
2948
2949 static inline ProtocolHandler *impl_from_IInternetProtocolEx(IInternetProtocolEx *iface)
2950 {
2951     return CONTAINING_RECORD(iface, ProtocolHandler, IInternetProtocolEx_iface);
2952 }
2953
2954 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
2955 {
2956     ProtocolHandler *This = impl_from_IInternetProtocolEx(iface);
2957
2958     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid) || IsEqualGUID(&IID_IInternetProtocolEx, riid)) {
2959         *ppv = &This->IInternetProtocolEx_iface;
2960     }else if(IsEqualGUID(&IID_IWinInetInfo, riid) || IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
2961         *ppv = &This->IWinInetHttpInfo_iface;
2962     }else {
2963         *ppv = NULL;
2964         return E_NOINTERFACE;
2965     }
2966
2967     IUnknown_AddRef((IUnknown*)*ppv);
2968     return S_OK;
2969 }
2970
2971 static ULONG WINAPI Protocol_AddRef(IInternetProtocolEx *iface)
2972 {
2973     ProtocolHandler *This = impl_from_IInternetProtocolEx(iface);
2974     return InterlockedIncrement(&This->ref);
2975 }
2976
2977 static ULONG WINAPI Protocol_Release(IInternetProtocolEx *iface)
2978 {
2979     ProtocolHandler *This = impl_from_IInternetProtocolEx(iface);
2980     LONG ref = InterlockedDecrement(&This->ref);
2981
2982     if(!ref) {
2983         if(This->sink)
2984             IInternetProtocolSink_Release(This->sink);
2985         if(This->stream)
2986             IStream_Release(This->stream);
2987         if(This->uri)
2988             IUri_Release(This->uri);
2989         ReleaseBindInfo(&This->bind_info);
2990         HeapFree(GetProcessHeap(), 0, This);
2991     }
2992
2993     return ref;
2994 }
2995
2996 static HRESULT WINAPI Protocol_Start(IInternetProtocolEx *iface, LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink,
2997         IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved)
2998 {
2999     ok(0, "unexpected call\n");
3000     return E_NOTIMPL;
3001 }
3002
3003 static HRESULT WINAPI Protocol_Continue(IInternetProtocolEx *iface, PROTOCOLDATA *pProtocolData)
3004 {
3005     ProtocolHandler *This = impl_from_IInternetProtocolEx(iface);
3006     report_data(This);
3007     IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
3008     return S_OK;
3009 }
3010
3011 static HRESULT WINAPI Protocol_Abort(IInternetProtocolEx *iface, HRESULT hrReason, DWORD dwOptions)
3012 {
3013     trace("Abort(%08x %x)\n", hrReason, dwOptions);
3014     return E_NOTIMPL;
3015 }
3016
3017 static HRESULT WINAPI Protocol_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
3018 {
3019     return S_OK;
3020 }
3021
3022 static HRESULT WINAPI Protocol_Suspend(IInternetProtocolEx *iface)
3023 {
3024     ok(0, "unexpected call\n");
3025     return E_NOTIMPL;
3026 }
3027
3028 static HRESULT WINAPI Protocol_Resume(IInternetProtocolEx *iface)
3029 {
3030     ok(0, "unexpected call\n");
3031     return E_NOTIMPL;
3032 }
3033
3034 static HRESULT WINAPI Protocol_Read(IInternetProtocolEx *iface, void *pv, ULONG cb, ULONG *pcbRead)
3035 {
3036     ProtocolHandler *This = impl_from_IInternetProtocolEx(iface);
3037     ULONG read;
3038     HRESULT hres;
3039
3040     if(This->stream) {
3041         hres = IStream_Read(This->stream, pv, cb, &read);
3042         ok(SUCCEEDED(hres), "Read failed: %08x\n", hres);
3043         if(FAILED(hres))
3044             return hres;
3045         if(pcbRead)
3046             *pcbRead = read;
3047         return read ? S_OK : S_FALSE;
3048     }
3049
3050     read = This->size - (This->ptr - This->data);
3051     if(read > cb)
3052         read = cb;
3053
3054     if(read) {
3055         memcpy(pv, This->ptr, read);
3056         This->ptr += read;
3057     }
3058
3059     *pcbRead = read;
3060     return This->ptr == This->data+This->size ? S_FALSE : S_OK;
3061 }
3062
3063 static HRESULT WINAPI Protocol_Seek(IInternetProtocolEx *iface,
3064         LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
3065 {
3066     ok(0, "unexpected call\n");
3067     return E_NOTIMPL;
3068 }
3069
3070 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
3071 {
3072     return S_OK;
3073 }
3074
3075 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocolEx *iface)
3076 {
3077     return S_OK;
3078 }
3079
3080 static HRESULT WINAPI ProtocolEx_StartEx(IInternetProtocolEx *iface, IUri *uri, IInternetProtocolSink *pOIProtSink,
3081         IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE *dwReserved)
3082 {
3083     ProtocolHandler *This = impl_from_IInternetProtocolEx(iface);
3084     BOOL block = FALSE;
3085     DWORD bindf;
3086     BSTR path;
3087     HRSRC src;
3088     HRESULT hres;
3089
3090     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &This->bind_info);
3091     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
3092
3093     hres = IUri_GetPath(uri, &path);
3094     if(FAILED(hres))
3095         return hres;
3096
3097     if(!strcmp_wa(path, "/index.html")) {
3098         This->data = index_html_data;
3099         This->size = strlen(This->data);
3100     }else if(!strcmp_wa(path, "/echo.php")) {
3101         ok(This->bind_info.dwBindVerb == BINDVERB_POST, "unexpected bind verb %d\n", This->bind_info.dwBindVerb == BINDVERB_POST);
3102         todo_wine ok(This->bind_info.stgmedData.tymed == TYMED_ISTREAM, "tymed = %x\n", This->bind_info.stgmedData.tymed);
3103         switch(This->bind_info.stgmedData.tymed) {
3104         case TYMED_HGLOBAL:
3105             This->size = This->bind_info.cbstgmedData;
3106             This->data = U(This->bind_info.stgmedData).hGlobal;
3107             break;
3108         case TYMED_ISTREAM:
3109             This->stream = U(This->bind_info.stgmedData).pstm;
3110             IStream_AddRef(This->stream);
3111             break;
3112         default:
3113             ok(0, "unexpected tymed %d\n", This->bind_info.stgmedData.tymed);
3114         }
3115     }else if(!strcmp_wa(path, "/jsstream.php")) {
3116         BSTR query;
3117
3118         hres = IUri_GetQuery(uri, &query);
3119         ok(hres == S_OK, "GetQuery failed: %08x\n", hres);
3120         ok(SysStringLen(query) > 1 && *query == '?', "unexpected query %s\n", wine_dbgstr_w(query));
3121         register_stream(This, query+1);
3122         SysFreeString(query);
3123         block = TRUE;
3124     }else {
3125         src = FindResourceW(NULL, *path == '/' ? path+1 : path, (const WCHAR*)RT_HTML);
3126         ok(src != NULL, "Could not find resource for path %s\n", wine_dbgstr_w(path));
3127         if(src) {
3128             This->size = SizeofResource(NULL, src);
3129             This->data = LoadResource(NULL, src);
3130         }else {
3131             hres = E_FAIL;
3132         }
3133     }
3134
3135     SysFreeString(path);
3136     if(FAILED(hres))
3137         return hres;
3138
3139     IInternetProtocolSink_AddRef(This->sink = pOIProtSink);
3140     IUri_AddRef(This->uri = uri);
3141
3142     This->ptr = This->data;
3143     if(!block)
3144         async_switch(This);
3145     return E_PENDING;
3146 }
3147
3148 static const IInternetProtocolExVtbl ProtocolExVtbl = {
3149     Protocol_QueryInterface,
3150     Protocol_AddRef,
3151     Protocol_Release,
3152     Protocol_Start,
3153     Protocol_Continue,
3154     Protocol_Abort,
3155     Protocol_Terminate,
3156     Protocol_Suspend,
3157     Protocol_Resume,
3158     Protocol_Read,
3159     Protocol_Seek,
3160     Protocol_LockRequest,
3161     Protocol_UnlockRequest,
3162     ProtocolEx_StartEx
3163 };
3164
3165 static inline ProtocolHandler *impl_from_IWinInetHttpInfo(IWinInetHttpInfo *iface)
3166 {
3167     return CONTAINING_RECORD(iface, ProtocolHandler, IWinInetHttpInfo_iface);
3168 }
3169
3170 static HRESULT WINAPI HttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
3171 {
3172     ProtocolHandler *This = impl_from_IWinInetHttpInfo(iface);
3173     return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
3174 }
3175
3176 static ULONG WINAPI HttpInfo_AddRef(IWinInetHttpInfo *iface)
3177 {
3178     ProtocolHandler *This = impl_from_IWinInetHttpInfo(iface);
3179     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
3180 }
3181
3182 static ULONG WINAPI HttpInfo_Release(IWinInetHttpInfo *iface)
3183 {
3184     ProtocolHandler *This = impl_from_IWinInetHttpInfo(iface);
3185     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
3186 }
3187
3188 static HRESULT WINAPI HttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
3189         void *pBuffer, DWORD *pcbBuffer)
3190 {
3191     return E_NOTIMPL;
3192 }
3193
3194 static HRESULT WINAPI HttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
3195         void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
3196 {
3197     return E_NOTIMPL;
3198 }
3199
3200 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
3201     HttpInfo_QueryInterface,
3202     HttpInfo_AddRef,
3203     HttpInfo_Release,
3204     HttpInfo_QueryOption,
3205     HttpInfo_QueryInfo
3206 };
3207
3208 static HRESULT WINAPI ProtocolCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
3209 {
3210     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
3211         *ppv = iface;
3212         return S_OK;
3213     }
3214
3215     *ppv = NULL;
3216     return E_NOINTERFACE;
3217 }
3218
3219 static HRESULT WINAPI ProtocolCF_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
3220 {
3221     ProtocolHandler *protocol;
3222     HRESULT hres;
3223
3224     protocol = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*protocol));
3225     protocol->IInternetProtocolEx_iface.lpVtbl = &ProtocolExVtbl;
3226     protocol->IWinInetHttpInfo_iface.lpVtbl = &WinInetHttpInfoVtbl;
3227     protocol->ref = 1;
3228     protocol->bind_info.cbSize = sizeof(protocol->bind_info);
3229
3230     hres = IInternetProtocolEx_QueryInterface(&protocol->IInternetProtocolEx_iface, riid, ppv);
3231     IInternetProtocolEx_Release(&protocol->IInternetProtocolEx_iface);
3232     return hres;
3233 }
3234
3235 static const IClassFactoryVtbl ProtocolCFVtbl = {
3236     ProtocolCF_QueryInterface,
3237     ClassFactory_AddRef,
3238     ClassFactory_Release,
3239     ProtocolCF_CreateInstance,
3240     ClassFactory_LockServer
3241 };
3242
3243 static IClassFactory protocol_cf = { &ProtocolCFVtbl };
3244
3245 static const char simple_script_str[] =
3246     "<html><head></head><body>"
3247     "<div id=\"divid\"></div>"
3248     "<script language=\"TestScript\">simple script</script>"
3249     "</body></html>";
3250
3251 static void test_exec_script(IHTMLDocument2 *doc, const char *codea, const char *langa)
3252 {
3253     IHTMLWindow2 *window;
3254     BSTR code, lang;
3255     VARIANT v;
3256     HRESULT hres;
3257
3258     hres = IHTMLDocument2_get_parentWindow(doc, &window);
3259     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
3260
3261     code = a2bstr(codea);
3262     lang = a2bstr(langa);
3263
3264     SET_EXPECT(ParseScriptText_execScript);
3265     hres = IHTMLWindow2_execScript(window, code, lang, &v);
3266     ok(hres == S_OK, "execScript failed: %08x\n", hres);
3267     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
3268     ok(V_I4(&v) == 10, "V_I4(v) = %d\n", V_I4(&v));
3269     CHECK_CALLED(ParseScriptText_execScript);
3270     SysFreeString(lang);
3271
3272     lang = a2bstr("invalid");
3273     V_VT(&v) = 100;
3274     hres = IHTMLWindow2_execScript(window, code, lang, &v);
3275     ok(hres == CO_E_CLASSSTRING, "execScript failed: %08x, expected CO_E_CLASSSTRING\n", hres);
3276     ok(V_VT(&v) == 100, "V_VT(v) = %d\n", V_VT(&v));
3277     SysFreeString(lang);
3278     SysFreeString(code);
3279
3280     IHTMLWindow2_Release(window);
3281 }
3282
3283 static void test_simple_script(void)
3284 {
3285     IHTMLDocument2 *doc;
3286
3287     doc = create_document();
3288     if(!doc)
3289         return;
3290
3291     SET_EXPECT(CreateInstance);
3292     SET_EXPECT(GetInterfaceSafetyOptions);
3293     SET_EXPECT(SetInterfaceSafetyOptions);
3294     SET_EXPECT(SetProperty_INVOKEVERSIONING); /* IE8 */
3295     SET_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
3296     SET_EXPECT(InitNew);
3297     SET_EXPECT(SetScriptSite);
3298     SET_EXPECT(GetScriptState);
3299     SET_EXPECT(SetScriptState_STARTED);
3300     SET_EXPECT(AddNamedItem);
3301     SET_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
3302     SET_EXPECT(ParseScriptText_script);
3303     SET_EXPECT(SetScriptState_CONNECTED);
3304
3305     load_doc(doc, simple_script_str);
3306
3307     CHECK_CALLED(CreateInstance);
3308     CHECK_CALLED(GetInterfaceSafetyOptions);
3309     CHECK_CALLED(SetInterfaceSafetyOptions);
3310     CHECK_CALLED_BROKEN(SetProperty_INVOKEVERSIONING); /* IE8 */
3311     CHECK_CALLED(SetProperty_HACK_TRIDENTEVENTSINK);
3312     CHECK_CALLED(InitNew);
3313     CHECK_CALLED(SetScriptSite);
3314     CHECK_CALLED(GetScriptState);
3315     CHECK_CALLED(SetScriptState_STARTED);
3316     CHECK_CALLED(AddNamedItem);
3317     CHECK_CALLED_BROKEN(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
3318     CHECK_CALLED(ParseScriptText_script);
3319     CHECK_CALLED(SetScriptState_CONNECTED);
3320
3321     test_exec_script(doc, "execScript call", "TestScript");
3322
3323     if(site)
3324         IActiveScriptSite_Release(site);
3325     if(window_dispex)
3326         IDispatchEx_Release(window_dispex);
3327
3328     SET_EXPECT(SetScriptState_DISCONNECTED);
3329     SET_EXPECT(Close);
3330
3331     IHTMLDocument2_Release(doc);
3332
3333     CHECK_CALLED(SetScriptState_DISCONNECTED);
3334     CHECK_CALLED(Close);
3335 }
3336
3337 static void run_from_moniker(IMoniker *mon)
3338 {
3339     IPersistMoniker *persist;
3340     IHTMLDocument2 *doc;
3341     MSG msg;
3342     HRESULT hres;
3343
3344     doc = create_document();
3345     if(!doc)
3346         return;
3347
3348     set_client_site(doc, TRUE);
3349     do_advise(doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
3350
3351     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&persist);
3352     ok(hres == S_OK, "Could not get IPersistMoniker iface: %08x\n", hres);
3353
3354     hres = IPersistMoniker_Load(persist, FALSE, mon, NULL, 0);
3355     ok(hres == S_OK, "Load failed: %08x\n", hres);
3356
3357     IPersistMoniker_Release(persist);
3358
3359     SET_EXPECT(external_success);
3360
3361     while(!called_external_success && GetMessageW(&msg, NULL, 0, 0)) {
3362         TranslateMessage(&msg);
3363         DispatchMessageW(&msg);
3364     }
3365
3366     CHECK_CALLED(external_success);
3367
3368     free_registered_streams();
3369     set_client_site(doc, FALSE);
3370     IHTMLDocument2_Release(doc);
3371 }
3372
3373 static void run_js_script(const char *test_name)
3374 {
3375     WCHAR url[INTERNET_MAX_URL_LENGTH] = {'r','e','s',':','/','/'}, *ptr;
3376     IMoniker *mon;
3377     HRESULT hres;
3378
3379     trace("running %s...\n", test_name);
3380
3381     ptr = url + lstrlenW(url);
3382     ptr += GetModuleFileNameW(NULL, ptr, url + ARRAY_SIZE(url) - ptr);
3383     *ptr++ = '/';
3384     MultiByteToWideChar(CP_ACP, 0, test_name, -1, ptr, url + ARRAY_SIZE(url) - ptr);
3385
3386     hres = CreateURLMoniker(NULL, url, &mon);
3387     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
3388     run_from_moniker(mon);
3389
3390     IMoniker_Release(mon);
3391 }
3392
3393 static void run_from_path(const char *path, const char *opt)
3394 {
3395     char buf[255] = "http://winetest.example.org";
3396     IMoniker *mon;
3397     BSTR url;
3398     HRESULT hres;
3399
3400     strcat(buf, path);
3401     if(opt)
3402         strcat(buf, opt);
3403     url = a2bstr(buf);
3404     hres = CreateURLMoniker(NULL, url, &mon);
3405     SysFreeString(url);
3406     ok(hres == S_OK, "CreateUrlMoniker failed: %08x\n", hres);
3407
3408     run_from_moniker(mon);
3409
3410     IMoniker_Release(mon);
3411 }
3412
3413 static void run_script_as_http_with_mode(const char *script, const char *opt, const char *document_mode)
3414 {
3415     trace("Running %s script in %s mode...\n", script, document_mode ? document_mode : "quirks");
3416
3417     sprintf(index_html_data,
3418             "%s"
3419             "<html>\n"
3420             "  <head>\n"
3421             "    %s%s%s\n"
3422             "    <script src=\"winetest.js\" type=\"text/javascript\"></script>\n"
3423             "    <script src=\"%s\" type=\"text/javascript\"></script>\n"
3424             "  </head>\n"
3425             "  <body onload=\"run_tests();\">\n"
3426             "  </body>\n"
3427             "</html>\n",
3428             document_mode ? "<!DOCTYPE html>\n" : "",
3429             document_mode ? "<meta http-equiv=\"x-ua-compatible\" content=\"Ie=" : "",
3430             document_mode ? document_mode : "",
3431             document_mode ? "\">" : "",
3432             script);
3433
3434     run_from_path("/index.html", opt);
3435 }
3436
3437 static void init_protocol_handler(void)
3438 {
3439     IInternetSession *internet_session;
3440     HRESULT hres;
3441
3442     static const WCHAR httpW[] = {'h','t','t','p',0};
3443
3444     hres = CoInternetGetSession(0, &internet_session, 0);
3445     ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
3446
3447     hres = IInternetSession_RegisterNameSpace(internet_session, &protocol_cf, &CLSID_HttpProtocol, httpW, 0, NULL, 0);
3448     ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
3449
3450     IInternetSession_Release(internet_session);
3451 }
3452
3453 static void run_js_tests(void)
3454 {
3455     run_js_script("jstest.html");
3456     run_js_script("exectest.html");
3457     run_js_script("events.html");
3458
3459     SET_EXPECT(GetTypeInfo);
3460     run_js_script("vbtest.html");
3461     CLEAR_CALLED(GetTypeInfo);
3462
3463     if(!is_ie9plus) {
3464         win_skip("Skipping some script tests on IE older than 9.\n");
3465         return;
3466     }
3467
3468     init_protocol_handler();
3469
3470     run_script_as_http_with_mode("xhr.js", NULL, "9");
3471     run_script_as_http_with_mode("xhr.js", NULL, "11");
3472     run_script_as_http_with_mode("elements.js", NULL, "11");
3473     run_script_as_http_with_mode("es5.js", NULL, "11");
3474     run_script_as_http_with_mode("events.js", NULL, "9");
3475     run_script_as_http_with_mode("navigation.js", NULL, NULL);
3476     run_script_as_http_with_mode("navigation.js", NULL, "11");
3477
3478     run_script_as_http_with_mode("documentmode.js", "?0", NULL);
3479     run_script_as_http_with_mode("documentmode.js", "?5", "5");
3480     run_script_as_http_with_mode("documentmode.js", "?5", "6");
3481     run_script_as_http_with_mode("documentmode.js", "?7", "7");
3482     run_script_as_http_with_mode("documentmode.js", "?8", "8");
3483     run_script_as_http_with_mode("documentmode.js", "?9", "9");
3484     run_script_as_http_with_mode("documentmode.js", "?10", "10");
3485     run_script_as_http_with_mode("documentmode.js", "?11", "11");
3486     run_script_as_http_with_mode("documentmode.js", "?11", "edge");
3487
3488     run_script_as_http_with_mode("asyncscriptload.js", NULL, "9");
3489 }
3490
3491 static BOOL init_registry(BOOL init)
3492 {
3493     return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
3494         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
3495                     NULL, init)
3496         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
3497                     NULL, init);
3498 }
3499
3500 static BOOL register_script_engine(void)
3501 {
3502     DWORD regid;
3503     HRESULT hres;
3504
3505     if(!init_registry(TRUE)) {
3506         init_registry(FALSE);
3507         return FALSE;
3508     }
3509
3510     hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
3511                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
3512     ok(hres == S_OK, "Could not register script engine: %08x\n", hres);
3513
3514     return TRUE;
3515 }
3516
3517 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
3518 {
3519     return DefWindowProcA(hwnd, msg, wParam, lParam);
3520 }
3521
3522 static HWND create_container_window(void)
3523 {
3524     static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
3525     static WNDCLASSEXA wndclass = {
3526         sizeof(WNDCLASSEXA),
3527         0,
3528         wnd_proc,
3529         0, 0, NULL, NULL, NULL, NULL, NULL,
3530         szHTMLDocumentTest,
3531         NULL
3532     };
3533
3534     RegisterClassExA(&wndclass);
3535     return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
3536             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
3537             300, 300, NULL, NULL, NULL, NULL);
3538 }
3539
3540 static BOOL check_ie(void)
3541 {
3542     IHTMLDocument2 *doc;
3543     IHTMLDocument5 *doc5;
3544     IHTMLDocument7 *doc7;
3545     HRESULT hres;
3546
3547     doc = create_document();
3548     if(!doc)
3549         return FALSE;
3550
3551     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument7, (void**)&doc7);
3552     if(SUCCEEDED(hres)) {
3553         is_ie9plus = TRUE;
3554         IHTMLDocument7_Release(doc7);
3555     }
3556
3557     trace("is_ie9plus %x\n", is_ie9plus);
3558
3559     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
3560     if(SUCCEEDED(hres))
3561         IHTMLDocument5_Release(doc5);
3562
3563     IHTMLDocument2_Release(doc);
3564     return SUCCEEDED(hres);
3565 }
3566
3567 START_TEST(script)
3568 {
3569     CoInitialize(NULL);
3570     container_hwnd = create_container_window();
3571
3572     if(check_ie()) {
3573         if(winetest_interactive || ! is_ie_hardened()) {
3574             if(register_script_engine()) {
3575                 test_simple_script();
3576                 init_registry(FALSE);
3577             }else {
3578                 skip("Could not register TestScript engine\n");
3579             }
3580             run_js_tests();
3581         }else {
3582             skip("IE running in Enhanced Security Configuration\n");
3583         }
3584     }else {
3585         win_skip("Too old IE.\n");
3586     }
3587
3588     DestroyWindow(container_hwnd);
3589     CoUninitialize();
3590 }