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(ChangeType);
 136
 137 #define TESTSCRIPT_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80746}"
 138 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80646}"
 139
 140 #define DISPID_SCRIPT_TESTPROP   0x100000
 141 #define DISPID_SCRIPT_TESTPROP2  0x100001
 142
 143 #define DISPID_EXTERNAL_OK             0x300000
 144 #define DISPID_EXTERNAL_TRACE          0x300001
 145 #define DISPID_EXTERNAL_REPORTSUCCESS  0x300002
 146 #define DISPID_EXTERNAL_TODO_WINE_OK   0x300003
 147
 148 static const GUID CLSID_TestScript =
 149     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x07,0x46}};
 150 static const GUID CLSID_TestActiveX =
 151     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
 152
 153 static IHTMLDocument2 *notif_doc;
 154 static IOleDocumentView *view;
 155 static IDispatchEx *window_dispex;
 156 static BOOL doc_complete;
 157 static IDispatch *script_disp;
 158 static BOOL ax_objsafe;
 159 static HWND container_hwnd;
 160 static HRESULT ax_getopt_hres = S_OK, ax_setopt_dispex_hres = S_OK;
 161 static HRESULT ax_setopt_disp_caller_hres = S_OK, ax_setopt_disp_data_hres = S_OK;
 162 static BOOL skip_loadobject_tests;
 163
 164 static int strcmp_wa(LPCWSTR strw, const char *stra)
 165 {
 166     CHAR buf[512];
 167     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 168     return lstrcmpA(stra, buf);
 169 }
 170
 171 static BSTR a2bstr(const char *str)
 172 {
 173     BSTR ret;
 174     int len;
 175
 176     if(!str)
 177         return NULL;
 178
 179     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 180     ret = SysAllocStringLen(NULL, len);
 181     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 182
 183     return ret;
 184 }
 185
 186 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 187 {
 188     HKEY hkey;
 189     DWORD res;
 190
 191     if(!init) {
 192         RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
 193         return TRUE;
 194     }
 195
 196     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 197     if(res != ERROR_SUCCESS)
 198         return FALSE;
 199
 200     if(def_value)
 201         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 202
 203     RegCloseKey(hkey);
 204
 205     return res == ERROR_SUCCESS;
 206 }
 207
 208 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 209         REFIID riid, void**ppv)
 210 {
 211     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 212         *ppv = iface;
 213         return S_OK;
 214     }
 215
 216     return E_NOINTERFACE;
 217 }
 218
 219 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 220 {
 221     return 2;
 222 }
 223
 224 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 225 {
 226     return 1;
 227 }
 228
 229 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 230 {
 231     if(dispID == DISPID_READYSTATE){
 232         BSTR state;
 233         HRESULT hres;
 234
 235         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
 236
 237         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
 238         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 239
 240         if(!lstrcmpW(state, completeW))
 241             doc_complete = TRUE;
 242
 243         SysFreeString(state);
 244     }
 245
 246     return S_OK;
 247 }
 248
 249 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 250 {
 251     ok(0, "unexpected call\n");
 252     return E_NOTIMPL;
 253 }
 254
 255 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 256     PropertyNotifySink_QueryInterface,
 257     PropertyNotifySink_AddRef,
 258     PropertyNotifySink_Release,
 259     PropertyNotifySink_OnChanged,
 260     PropertyNotifySink_OnRequestEdit
 261 };
 262
 263 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 264
 265 static HRESULT WINAPI VariantChangeType_QueryInterface(IVariantChangeType *iface, REFIID riid, void **ppv)
 266 {
 267     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
 268     *ppv = NULL;
 269     return E_NOINTERFACE;
 270 }
 271
 272 static ULONG WINAPI VariantChangeType_AddRef(IVariantChangeType *iface)
 273 {
 274     return 2;
 275 }
 276
 277 static ULONG WINAPI VariantChangeType_Release(IVariantChangeType *iface)
 278 {
 279     return 1;
 280 }
 281
 282 static HRESULT WINAPI VariantChangeType_ChangeType(IVariantChangeType *iface, VARIANT *dst, VARIANT *src, LCID lcid, VARTYPE vt)
 283 {
 284     CHECK_EXPECT(ChangeType);
 285
 286     ok(dst != NULL, "dst = NULL\n");
 287     ok(V_VT(dst) == VT_EMPTY, "V_VT(dst) = %d\n", V_VT(dst));
 288     ok(src != NULL, "src = NULL\n");
 289     ok(V_VT(src) == VT_I4, "V_VT(src) = %d\n", V_VT(src));
 290     ok(V_I4(src) == 0xf0f0f0, "V_I4(src) = %x\n", V_I4(src));
 291     ok(lcid == LOCALE_NEUTRAL, "lcid = %d\n", lcid);
 292     ok(vt == VT_BSTR, "vt = %d\n", vt);
 293
 294     V_VT(dst) = VT_BSTR;
 295     V_BSTR(dst) = a2bstr("red");
 296     return S_OK;
 297 }
 298
 299 static const IVariantChangeTypeVtbl VariantChangeTypeVtbl = {
 300     VariantChangeType_QueryInterface,
 301     VariantChangeType_AddRef,
 302     VariantChangeType_Release,
 303     VariantChangeType_ChangeType
 304 };
 305
 306 static IVariantChangeType VChangeType = { &VariantChangeTypeVtbl };
 307
 308 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 309 {
 310     ok(0, "unexpected call\n");
 311     return E_NOINTERFACE;
 312 }
 313
 314 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 315 {
 316     return 2;
 317 }
 318
 319 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 320 {
 321     return 1;
 322 }
 323
 324 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
 325         REFIID riid, void **ppv)
 326 {
 327     if(IsEqualGUID(guidService, &SID_VariantConversion)) {
 328         CHECK_EXPECT(QS_VariantConversion);
 329         ok(IsEqualGUID(riid, &IID_IVariantChangeType), "uenxpected riid %s\n", wine_dbgstr_guid(riid));
 330         *ppv = &VChangeType;
 331         return S_OK;
 332     }
 333
 334     ok(0, "unexpected service %s\n", wine_dbgstr_guid(guidService));
 335     return E_NOINTERFACE;
 336 }
 337
 338 static const IServiceProviderVtbl ServiceProviderVtbl = {
 339     ServiceProvider_QueryInterface,
 340     ServiceProvider_AddRef,
 341     ServiceProvider_Release,
 342     ServiceProvider_QueryService
 343 };
 344
 345 static IServiceProvider caller_sp = { &ServiceProviderVtbl };
 346
 347 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 348 {
 349     *ppv = NULL;
 350
 351     if(IsEqualGUID(riid, &IID_IUnknown)
 352        || IsEqualGUID(riid, &IID_IDispatch)
 353        || IsEqualGUID(riid, &IID_IDispatchEx))
 354         *ppv = iface;
 355     else
 356         return E_NOINTERFACE;
 357
 358     return S_OK;
 359 }
 360
 361 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 362 {
 363     return 2;
 364 }
 365
 366 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 367 {
 368     return 1;
 369 }
 370
 371 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 372 {
 373     ok(0, "unexpected call\n");
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 378                                               LCID lcid, ITypeInfo **ppTInfo)
 379 {
 380     ok(0, "unexpected call\n");
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 385                                                 LPOLESTR *rgszNames, UINT cNames,
 386                                                 LCID lcid, DISPID *rgDispId)
 387 {
 388     ok(0, "unexpected call\n");
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 393                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 394                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 395 {
 396     ok(0, "unexpected call\n");
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 401 {
 402     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 407 {
 408     ok(0, "unexpected call\n");
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 413 {
 414     ok(0, "unexpected call\n");
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 419 {
 420     ok(0, "unexpected call\n");
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 425 {
 426     ok(0, "unexpected call\n");
 427     return E_NOTIMPL;
 428 }
 429
 430 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 431 {
 432     ok(0, "unexpected call\n");
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 437 {
 438     ok(0, "unexpected call\n");
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI funcDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 443         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 444 {
 445     CHECK_EXPECT(funcDisp);
 446
 447     ok(id == DISPID_VALUE, "id = %d\n", id);
 448     ok(lcid == 0, "lcid = %x\n", lcid);
 449     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 450     ok(pdp != NULL, "pdp == NULL\n");
 451     ok(pdp->cArgs == 2, "pdp->cArgs = %d\n", pdp->cArgs);
 452     ok(pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 453     ok(pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
 454     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 455     ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(rgvarg[1]) = %d\n", V_VT(pdp->rgvarg));
 456     ok(V_BOOL(pdp->rgvarg+1) == VARIANT_TRUE, "V_BOOL(rgvarg[1]) = %x\n", V_BOOL(pdp->rgvarg));
 457     ok(pvarRes != NULL, "pvarRes == NULL\n");
 458     ok(pei != NULL, "pei == NULL\n");
 459     ok(!pspCaller, "pspCaller != NULL\n");
 460
 461     V_VT(pvarRes) = VT_I4;
 462     V_I4(pvarRes) = 100;
 463     return S_OK;
 464 }
 465
 466 static IDispatchExVtbl testObjVtbl = {
 467     DispatchEx_QueryInterface,
 468     DispatchEx_AddRef,
 469     DispatchEx_Release,
 470     DispatchEx_GetTypeInfoCount,
 471     DispatchEx_GetTypeInfo,
 472     DispatchEx_GetIDsOfNames,
 473     DispatchEx_Invoke,
 474     DispatchEx_GetDispID,
 475     funcDisp_InvokeEx,
 476     DispatchEx_DeleteMemberByName,
 477     DispatchEx_DeleteMemberByDispID,
 478     DispatchEx_GetMemberProperties,
 479     DispatchEx_GetMemberName,
 480     DispatchEx_GetNextDispID,
 481     DispatchEx_GetNameSpaceParent
 482 };
 483
 484 static IDispatchEx funcDisp = { &testObjVtbl };
 485
 486 static HRESULT WINAPI scriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 487 {
 488     if(!strcmp_wa(bstrName, "testProp")) {
 489         CHECK_EXPECT(script_testprop_d);
 490         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 491         *pid = DISPID_SCRIPT_TESTPROP;
 492         return S_OK;
 493     }
 494
 495     if(!strcmp_wa(bstrName, "testProp2")) {
 496         CHECK_EXPECT(script_testprop2_d);
 497         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 498         *pid = DISPID_SCRIPT_TESTPROP2;
 499         return S_OK;
 500     }
 501
 502     if(!strcmp_wa(bstrName, "divid")) {
 503         CHECK_EXPECT(script_divid_d);
 504         ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
 505         return E_FAIL;
 506     }
 507
 508     ok(0, "unexpected call %s\n", wine_dbgstr_w(bstrName));
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI scriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 513         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 514 {
 515     switch(id) {
 516     case DISPID_SCRIPT_TESTPROP:
 517         CHECK_EXPECT(script_testprop_i);
 518
 519         ok(lcid == 0, "lcid = %x\n", lcid);
 520         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 521         ok(pdp != NULL, "pdp == NULL\n");
 522         ok(pdp->cArgs == 0, "pdp->cArgs = %d\n", pdp->cArgs);
 523         ok(pdp->cNamedArgs == 0, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 524         ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs != NULL\n");
 525         ok(!pdp->rgvarg, "rgvarg != NULL\n");
 526         ok(pvarRes != NULL, "pvarRes == NULL\n");
 527         ok(pei != NULL, "pei == NULL\n");
 528         ok(!pspCaller, "pspCaller != NULL\n");
 529
 530         V_VT(pvarRes) = VT_NULL;
 531         break;
 532     default:
 533         ok(0, "unexpected call\n");
 534         return E_NOTIMPL;
 535     }
 536
 537     return S_OK;
 538 }
 539
 540 static IDispatchExVtbl scriptDispVtbl = {
 541     DispatchEx_QueryInterface,
 542     DispatchEx_AddRef,
 543     DispatchEx_Release,
 544     DispatchEx_GetTypeInfoCount,
 545     DispatchEx_GetTypeInfo,
 546     DispatchEx_GetIDsOfNames,
 547     DispatchEx_Invoke,
 548     scriptDisp_GetDispID,
 549     scriptDisp_InvokeEx,
 550     DispatchEx_DeleteMemberByName,
 551     DispatchEx_DeleteMemberByDispID,
 552     DispatchEx_GetMemberProperties,
 553     DispatchEx_GetMemberName,
 554     DispatchEx_GetNextDispID,
 555     DispatchEx_GetNameSpaceParent
 556 };
 557
 558 static IDispatchEx scriptDisp = { &scriptDispVtbl };
 559
 560 static HRESULT WINAPI externalDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 561 {
 562     if(!strcmp_wa(bstrName, "ok")) {
 563         *pid = DISPID_EXTERNAL_OK;
 564         return S_OK;
 565     }
 566     if(!strcmp_wa(bstrName, "trace")) {
 567         *pid = DISPID_EXTERNAL_TRACE;
 568         return S_OK;
 569     }
 570     if(!strcmp_wa(bstrName, "reportSuccess")) {
 571         *pid = DISPID_EXTERNAL_REPORTSUCCESS;
 572         return S_OK;
 573     }
 574     if(!strcmp_wa(bstrName, "todo_wine_ok")) {
 575         *pid = DISPID_EXTERNAL_TODO_WINE_OK;
 576         return S_OK;
 577     }
 578
 579     ok(0, "unexpected name %s\n", wine_dbgstr_w(bstrName));
 580     return DISP_E_UNKNOWNNAME;
 581 }
 582
 583 static HRESULT WINAPI externalDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 584         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 585 {
 586     switch(id) {
 587     case DISPID_EXTERNAL_OK: {
 588         VARIANT *b, *m;
 589
 590         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 591         ok(pdp != NULL, "pdp == NULL\n");
 592         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 593         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 594         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 595         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 596         ok(pei != NULL, "pei == NULL\n");
 597
 598         m = pdp->rgvarg;
 599         if(V_VT(m) == (VT_BYREF|VT_VARIANT))
 600             m = V_BYREF(m);
 601         ok(V_VT(m) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 602
 603         b = pdp->rgvarg+1;
 604         if(V_VT(b) == (VT_BYREF|VT_VARIANT))
 605             b = V_BYREF(b);
 606         ok(V_VT(b) == VT_BOOL, "V_VT(b) = %d\n", V_VT(b));
 607
 608         ok(V_BOOL(b), "%s\n", wine_dbgstr_w(V_BSTR(m)));
 609         return S_OK;
 610     }
 611
 612      case DISPID_EXTERNAL_TRACE:
 613         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 614         ok(pdp != NULL, "pdp == NULL\n");
 615         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 616         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 617         ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
 618         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 619         ok(!pvarRes, "pvarRes != NULL\n");
 620         ok(pei != NULL, "pei == NULL\n");
 621
 622         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 623         if(V_VT(pdp->rgvarg) == VT_BSTR)
 624             trace("%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 625
 626         return S_OK;
 627
 628     case DISPID_EXTERNAL_REPORTSUCCESS:
 629         CHECK_EXPECT(external_success);
 630
 631         ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
 632         ok(pdp != NULL, "pdp == NULL\n");
 633         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 634         ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
 635         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 636         ok(!pvarRes, "pvarRes != NULL\n");
 637         ok(pei != NULL, "pei == NULL\n");
 638
 639         return S_OK;
 640
 641     case DISPID_EXTERNAL_TODO_WINE_OK:
 642         ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
 643         ok(pdp != NULL, "pdp == NULL\n");
 644         ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
 645         ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
 646         ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
 647         ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
 648         ok(pei != NULL, "pei == NULL\n");
 649
 650         ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
 651         ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg));
 652         todo_wine
 653         ok(V_BOOL(pdp->rgvarg+1), "%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
 654
 655         return S_OK;
 656
 657     default:
 658         ok(0, "unexpected call\n");
 659         return E_NOTIMPL;
 660     }
 661
 662     return S_OK;
 663 }
 664
 665 static IDispatchExVtbl externalDispVtbl = {
 666     DispatchEx_QueryInterface,
 667     DispatchEx_AddRef,
 668     DispatchEx_Release,
 669     DispatchEx_GetTypeInfoCount,
 670     DispatchEx_GetTypeInfo,
 671     DispatchEx_GetIDsOfNames,
 672     DispatchEx_Invoke,
 673     externalDisp_GetDispID,
 674     externalDisp_InvokeEx,
 675     DispatchEx_DeleteMemberByName,
 676     DispatchEx_DeleteMemberByDispID,
 677     DispatchEx_GetMemberProperties,
 678     DispatchEx_GetMemberName,
 679     DispatchEx_GetNextDispID,
 680     DispatchEx_GetNameSpaceParent
 681 };
 682
 683 static IDispatchEx externalDisp = { &externalDispVtbl };
 684
 685 static HRESULT QueryInterface(REFIID,void**);
 686
 687 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
 688 {
 689     return QueryInterface(riid, ppv);
 690 }
 691
 692 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
 693 {
 694     return 2;
 695 }
 696
 697 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
 698 {
 699     return 1;
 700 }
 701
 702 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
 703         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
 704 {
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
 709 {
 710     return E_NOTIMPL;
 711 }
 712
 713 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
 714         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
 715         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
 716 {
 717     return S_OK;
 718 }
 719
 720 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
 721 {
 722     return S_OK;
 723 }
 724
 725 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
 726 {
 727     return S_OK;
 728 }
 729
 730 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
 731 {
 732     return E_NOTIMPL;
 733 }
 734
 735 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 736 {
 737     return E_NOTIMPL;
 738 }
 739
 740 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 741 {
 742     return S_OK;
 743 }
 744
 745 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
 746         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
 747 {
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
 752         const GUID *pguidCmdGroup, DWORD nCmdID)
 753 {
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
 758         LPOLESTR *pchKey, DWORD dw)
 759 {
 760     return S_OK;
 761 }
 762
 763 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
 764         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
 765 {
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
 770 {
 771     *ppDispatch = (IDispatch*)&externalDisp;
 772     return S_OK;
 773 }
 774
 775 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
 776         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
 777 {
 778     return S_FALSE;
 779 }
 780
 781 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
 782         IDataObject **ppPORet)
 783 {
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
 788         LPOLESTR *pchKey, DWORD dw)
 789 {
 790     return E_NOTIMPL;
 791 }
 792
 793 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
 794     DocHostUIHandler_QueryInterface,
 795     DocHostUIHandler_AddRef,
 796     DocHostUIHandler_Release,
 797     DocHostUIHandler_ShowContextMenu,
 798     DocHostUIHandler_GetHostInfo,
 799     DocHostUIHandler_ShowUI,
 800     DocHostUIHandler_HideUI,
 801     DocHostUIHandler_UpdateUI,
 802     DocHostUIHandler_EnableModeless,
 803     DocHostUIHandler_OnDocWindowActivate,
 804     DocHostUIHandler_OnFrameWindowActivate,
 805     DocHostUIHandler_ResizeBorder,
 806     DocHostUIHandler_TranslateAccelerator,
 807     DocHostUIHandler_GetOptionKeyPath,
 808     DocHostUIHandler_GetDropTarget,
 809     DocHostUIHandler_GetExternal,
 810     DocHostUIHandler_TranslateUrl,
 811     DocHostUIHandler_FilterDataObject,
 812     DocHostUIHandler_GetOverrideKeyPath
 813 };
 814
 815 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
 816
 817 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 818 {
 819     return E_NOINTERFACE;
 820 }
 821
 822 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 823 {
 824     return 2;
 825 }
 826
 827 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
 828 {
 829     return 1;
 830 }
 831
 832 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 833 {
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 838 {
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 843 {
 844     return E_NOTIMPL;
 845 }
 846
 847 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
 848         LPCBORDERWIDTHS pborderwidths)
 849 {
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
 854         LPCBORDERWIDTHS pborderwidths)
 855 {
 856     return S_OK;
 857 }
 858
 859 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 860         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 861 {
 862     return S_OK;
 863 }
 864
 865 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 866         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 867 {
 868     return E_NOTIMPL;
 869 }
 870
 871 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 872         HOLEMENU holemenu, HWND hwndActiveObject)
 873 {
 874     ok(0, "unexpected call\n");
 875     return E_NOTIMPL;
 876 }
 877
 878 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 879 {
 880     ok(0, "unexpected call\n");
 881     return E_NOTIMPL;
 882 }
 883
 884 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 885 {
 886     return S_OK;
 887 }
 888
 889 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 890 {
 891     return E_NOTIMPL;
 892 }
 893
 894 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 895 {
 896     ok(0, "unexpected call\n");
 897     return E_NOTIMPL;
 898 }
 899
 900 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 901     InPlaceFrame_QueryInterface,
 902     InPlaceFrame_AddRef,
 903     InPlaceFrame_Release,
 904     InPlaceFrame_GetWindow,
 905     InPlaceFrame_ContextSensitiveHelp,
 906     InPlaceFrame_GetBorder,
 907     InPlaceFrame_RequestBorderSpace,
 908     InPlaceFrame_SetBorderSpace,
 909     InPlaceFrame_SetActiveObject,
 910     InPlaceFrame_InsertMenus,
 911     InPlaceFrame_SetMenu,
 912     InPlaceFrame_RemoveMenus,
 913     InPlaceFrame_SetStatusText,
 914     InPlaceFrame_EnableModeless,
 915     InPlaceFrame_TranslateAccelerator
 916 };
 917
 918 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 919
 920 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
 921 {
 922     return QueryInterface(riid, ppv);
 923 }
 924
 925 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
 926 {
 927     return 2;
 928 }
 929
 930 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
 931 {
 932     return 1;
 933 }
 934
 935 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
 936 {
 937     *phwnd = container_hwnd;
 938     return S_OK;
 939 }
 940
 941 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
 942 {
 943     ok(0, "unexpected call\n");
 944     return E_NOTIMPL;
 945 }
 946
 947 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
 948 {
 949     return S_OK;
 950 }
 951
 952 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
 953 {
 954     return S_OK;
 955 }
 956
 957 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
 958 {
 959     return S_OK;
 960 }
 961
 962 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
 963         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 964         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 965 {
 966     static const RECT rect = {0,0,300,300};
 967
 968     *ppFrame = &InPlaceFrame;
 969     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceFrame;
 970     *lprcPosRect = rect;
 971     *lprcClipRect = rect;
 972
 973     ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
 974     lpFrameInfo->fMDIApp = FALSE;
 975     lpFrameInfo->hwndFrame = container_hwnd;
 976     lpFrameInfo->haccel = NULL;
 977     lpFrameInfo->cAccelEntries = 0;
 978
 979     return S_OK;
 980 }
 981
 982 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
 983 {
 984     return E_NOTIMPL;
 985 }
 986
 987 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
 988 {
 989     return S_OK;
 990 }
 991
 992 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
 993 {
 994     return S_OK;
 995 }
 996
 997 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
 998 {
 999     return E_NOTIMPL;
1000 }
1001
1002 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1003 {
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1008 {
1009     return E_NOTIMPL;
1010 }
1011
1012 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1013     InPlaceSite_QueryInterface,
1014     InPlaceSite_AddRef,
1015     InPlaceSite_Release,
1016     InPlaceSite_GetWindow,
1017     InPlaceSite_ContextSensitiveHelp,
1018     InPlaceSite_CanInPlaceActivate,
1019     InPlaceSite_OnInPlaceActivate,
1020     InPlaceSite_OnUIActivate,
1021     InPlaceSite_GetWindowContext,
1022     InPlaceSite_Scroll,
1023     InPlaceSite_OnUIDeactivate,
1024     InPlaceSite_OnInPlaceDeactivate,
1025     InPlaceSite_DiscardUndoState,
1026     InPlaceSite_DeactivateAndUndo,
1027     InPlaceSite_OnPosRectChange,
1028 };
1029
1030 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1031
1032 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1033 {
1034     return QueryInterface(riid, ppv);
1035 }
1036
1037 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1038 {
1039     return 2;
1040 }
1041
1042 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1043 {
1044     return 1;
1045 }
1046
1047 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1048 {
1049     ok(0, "unexpected call\n");
1050     return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1054         IMoniker **ppmon)
1055 {
1056     ok(0, "unexpected call\n");
1057     return E_NOTIMPL;
1058 }
1059
1060 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1061 {
1062     return E_NOTIMPL;
1063 }
1064
1065 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1066 {
1067     ok(0, "unexpected call\n");
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1072 {
1073     ok(0, "unexpected call\n");
1074     return E_NOTIMPL;
1075 }
1076
1077 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1078 {
1079     ok(0, "unexpected call\n");
1080     return E_NOTIMPL;
1081 }
1082
1083 static const IOleClientSiteVtbl ClientSiteVtbl = {
1084     ClientSite_QueryInterface,
1085     ClientSite_AddRef,
1086     ClientSite_Release,
1087     ClientSite_SaveObject,
1088     ClientSite_GetMoniker,
1089     ClientSite_GetContainer,
1090     ClientSite_ShowObject,
1091     ClientSite_OnShowWindow,
1092     ClientSite_RequestNewObjectLayout
1093 };
1094
1095 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1096
1097 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1098 {
1099     return QueryInterface(riid, ppv);
1100 }
1101
1102 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1103 {
1104     return 2;
1105 }
1106
1107 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1108 {
1109     return 1;
1110 }
1111
1112 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1113 {
1114     RECT rect = {0,0,300,300};
1115     IOleDocument *document;
1116     HRESULT hres;
1117
1118     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1119     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1120
1121     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1122     IOleDocument_Release(document);
1123     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1124
1125     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1126     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1127
1128     hres = IOleDocumentView_UIActivate(view, TRUE);
1129     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1130
1131     hres = IOleDocumentView_SetRect(view, &rect);
1132     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1133
1134     hres = IOleDocumentView_Show(view, TRUE);
1135     ok(hres == S_OK, "Show failed: %08x\n", hres);
1136
1137     return S_OK;
1138 }
1139
1140 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1141     DocumentSite_QueryInterface,
1142     DocumentSite_AddRef,
1143     DocumentSite_Release,
1144     DocumentSite_ActivateMe
1145 };
1146
1147 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1148
1149 static HRESULT QueryInterface(REFIID riid, void **ppv)
1150 {
1151     *ppv = NULL;
1152
1153     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1154         *ppv = &ClientSite;
1155     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1156         *ppv = &DocumentSite;
1157     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1158         *ppv = &InPlaceSite;
1159     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1160         *ppv = &DocHostUIHandler;
1161
1162     return *ppv ? S_OK : E_NOINTERFACE;
1163 }
1164
1165 static IHTMLDocument2 *create_document(void)
1166 {
1167     IHTMLDocument2 *doc;
1168     IHTMLDocument5 *doc5;
1169     HRESULT hres;
1170
1171     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1172             &IID_IHTMLDocument2, (void**)&doc);
1173     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1174     if (hres != S_OK) return NULL;
1175
1176     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
1177     if(FAILED(hres)) {
1178         win_skip("Could not get IHTMLDocument5, probably too old IE\n");
1179         IHTMLDocument2_Release(doc);
1180         return NULL;
1181     }
1182
1183     IHTMLDocument5_Release(doc5);
1184     return doc;
1185 }
1186
1187 static void load_string(IHTMLDocument2 *doc, const char *str)
1188 {
1189     IPersistStreamInit *init;
1190     IStream *stream;
1191     HGLOBAL mem;
1192     SIZE_T len;
1193
1194     doc_complete = FALSE;
1195     len = strlen(str);
1196     mem = GlobalAlloc(0, len);
1197     memcpy(mem, str, len);
1198     CreateStreamOnHGlobal(mem, TRUE, &stream);
1199
1200     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1201
1202     IPersistStreamInit_Load(init, stream);
1203     IPersistStreamInit_Release(init);
1204     IStream_Release(stream);
1205 }
1206
1207 static void do_advise(IHTMLDocument2 *doc, REFIID riid, IUnknown *unk_advise)
1208 {
1209     IConnectionPointContainer *container;
1210     IConnectionPoint *cp;
1211     DWORD cookie;
1212     HRESULT hres;
1213
1214     hres = IHTMLDocument2_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&container);
1215     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1216
1217     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1218     IConnectionPointContainer_Release(container);
1219     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1220
1221     notif_doc = doc;
1222
1223     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1224     IConnectionPoint_Release(cp);
1225     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1226 }
1227
1228 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1229 {
1230     IOleObject *oleobj;
1231     HRESULT hres;
1232
1233     if(!set && view) {
1234         IOleDocumentView_Show(view, FALSE);
1235         IOleDocumentView_CloseView(view, 0);
1236         IOleDocumentView_SetInPlaceSite(view, NULL);
1237         IOleDocumentView_Release(view);
1238         view = NULL;
1239     }
1240
1241     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1242     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1243
1244     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1245     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1246
1247     if(set) {
1248         IHlinkTarget *hlink;
1249
1250         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1251         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1252
1253         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1254         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1255
1256         IHlinkTarget_Release(hlink);
1257     }
1258
1259     IOleObject_Release(oleobj);
1260 }
1261
1262 typedef void (*domtest_t)(IHTMLDocument2*);
1263
1264 static void load_doc(IHTMLDocument2 *doc, const char *str)
1265 {
1266     IHTMLElement *body = NULL;
1267     MSG msg;
1268     HRESULT hres;
1269     static const WCHAR ucPtr[] = {'b','a','c','k','g','r','o','u','n','d',0};
1270     DISPID dispID = -1;
1271     OLECHAR *name;
1272
1273     load_string(doc, str);
1274     do_advise(doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1275
1276     while(!doc_complete && GetMessageW(&msg, NULL, 0, 0)) {
1277         TranslateMessage(&msg);
1278         DispatchMessageW(&msg);
1279     }
1280
1281     hres = IHTMLDocument2_get_body(doc, &body);
1282     ok(hres == S_OK, "get_body failed: %08x\n", hres);
1283
1284     /* Check we can query for function on the IHTMLElementBody interface */
1285     name = (WCHAR*)ucPtr;
1286     hres = IHTMLElement_GetIDsOfNames(body, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispID);
1287     ok(hres == S_OK, "GetIDsOfNames(background) failed %08x\n", hres);
1288     ok(dispID == DISPID_IHTMLBODYELEMENT_BACKGROUND, "Incorrect dispID got (%d)\n", dispID);
1289
1290     IHTMLElement_Release(body);
1291 }
1292
1293 static IActiveScriptSite *site;
1294 static SCRIPTSTATE state;
1295
1296 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1297 {
1298     *ppv = NULL;
1299     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
1300     return E_NOINTERFACE;
1301 }
1302
1303 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
1304 {
1305     return 2;
1306 }
1307
1308 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
1309 {
1310     return 1;
1311 }
1312
1313 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1314         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1315 {
1316     CHECK_EXPECT(GetInterfaceSafetyOptions);
1317
1318     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
1319     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
1320     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
1321
1322     *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
1323     *pdwEnabledOptions = INTERFACE_USES_DISPEX;
1324
1325     return S_OK;
1326 }
1327
1328 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1329         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1330 {
1331     CHECK_EXPECT(SetInterfaceSafetyOptions);
1332
1333     ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
1334
1335     ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
1336        "dwOptionSetMask=%x\n", dwOptionSetMask);
1337     ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
1338        "dwEnabledOptions=%x\n", dwOptionSetMask);
1339
1340     return S_OK;
1341 }
1342
1343 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1344     ObjectSafety_QueryInterface,
1345     ObjectSafety_AddRef,
1346     ObjectSafety_Release,
1347     ObjectSafety_GetInterfaceSafetyOptions,
1348     ObjectSafety_SetInterfaceSafetyOptions
1349 };
1350
1351 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
1352
1353 static HRESULT WINAPI AXObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1354 {
1355     *ppv = NULL;
1356
1357     if(IsEqualGUID(&IID_IActiveScript, riid)) {
1358         CHECK_EXPECT(AXQueryInterface_IActiveScript);
1359         return E_NOINTERFACE;
1360     }
1361
1362     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
1363         CHECK_EXPECT2(AXQueryInterface_IObjectSafety);
1364         if(!ax_objsafe)
1365             return E_NOINTERFACE;
1366         *ppv = iface;
1367         return S_OK;
1368     }
1369
1370     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
1371     return E_NOINTERFACE;
1372 }
1373
1374 static HRESULT WINAPI AXObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1375         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1376 {
1377     CHECK_EXPECT(AXGetInterfaceSafetyOptions);
1378
1379     ok(IsEqualGUID(&IID_IDispatchEx, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
1380     ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
1381     ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
1382
1383     if(SUCCEEDED(ax_getopt_hres)) {
1384         *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
1385         *pdwEnabledOptions = INTERFACE_USES_DISPEX;
1386     }
1387
1388     return ax_getopt_hres;
1389 }
1390
1391 static HRESULT WINAPI AXObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1392         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1393 {
1394     if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1395         switch(dwEnabledOptions) {
1396         case INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACE_USES_SECURITY_MANAGER:
1397             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1398             break;
1399         case INTERFACESAFE_FOR_UNTRUSTED_CALLER:
1400             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1401             break;
1402         default:
1403             ok(0, "unexpected dwEnabledOptions %x\n", dwEnabledOptions);
1404         }
1405
1406         ok(dwOptionSetMask == dwEnabledOptions, "dwOptionSetMask=%x, expected %x\n", dwOptionSetMask, dwEnabledOptions);
1407         return ax_setopt_dispex_hres;
1408     }
1409
1410     if(IsEqualGUID(&IID_IDispatch, riid)) {
1411         HRESULT hres;
1412
1413         switch(dwEnabledOptions) {
1414         case INTERFACESAFE_FOR_UNTRUSTED_CALLER:
1415             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1416             hres = ax_setopt_disp_caller_hres;
1417             break;
1418         case INTERFACESAFE_FOR_UNTRUSTED_DATA:
1419             CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1420             hres = ax_setopt_disp_data_hres;
1421             break;
1422         default:
1423             ok(0, "unexpected dwEnabledOptions %x\n", dwEnabledOptions);
1424             hres = E_FAIL;
1425         }
1426         ok(dwOptionSetMask == dwEnabledOptions, "dwOptionSetMask=%x, expected %x\n", dwOptionSetMask, dwEnabledOptions);
1427         return hres;
1428     }
1429
1430     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
1431     return E_NOINTERFACE;
1432 }
1433
1434 static const IObjectSafetyVtbl AXObjectSafetyVtbl = {
1435     AXObjectSafety_QueryInterface,
1436     ObjectSafety_AddRef,
1437     ObjectSafety_Release,
1438     AXObjectSafety_GetInterfaceSafetyOptions,
1439     AXObjectSafety_SetInterfaceSafetyOptions
1440 };
1441
1442 static IObjectSafety AXObjectSafety = { &AXObjectSafetyVtbl };
1443
1444 static BOOL set_safe_reg(BOOL safe_call, BOOL safe_data)
1445 {
1446     return init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
1447                     NULL, safe_call)
1448         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
1449                     NULL, safe_data);
1450 }
1451
1452 #define check_custom_policy(a,b,c,d) _check_custom_policy(__LINE__,a,b,c,d)
1453 static void _check_custom_policy(unsigned line, HRESULT hres, BYTE *ppolicy, DWORD policy_size, DWORD expolicy)
1454 {
1455     ok_(__FILE__,line)(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1456     ok_(__FILE__,line)(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1457     ok_(__FILE__,line)(*(DWORD*)ppolicy == expolicy, "policy = %x, expected %x\n", *(DWORD*)ppolicy, expolicy);
1458     CoTaskMemFree(ppolicy);
1459 }
1460
1461 static void test_security_reg(IInternetHostSecurityManager *sec_mgr, DWORD policy_caller, DWORD policy_load)
1462 {
1463     struct CONFIRMSAFETY cs;
1464     DWORD policy_size;
1465     BYTE *ppolicy;
1466     HRESULT hres;
1467
1468     cs.clsid = CLSID_TestActiveX;
1469     cs.pUnk = (IUnknown*)&AXObjectSafety;
1470
1471     cs.dwFlags = 0;
1472     ax_objsafe = FALSE;
1473     SET_EXPECT(AXQueryInterface_IActiveScript);
1474     SET_EXPECT(AXQueryInterface_IObjectSafety);
1475     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1476             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1477     CHECK_CALLED(AXQueryInterface_IActiveScript);
1478     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1479     check_custom_policy(hres, ppolicy, policy_size, policy_caller);
1480
1481     ax_objsafe = TRUE;
1482     SET_EXPECT(AXQueryInterface_IActiveScript);
1483     SET_EXPECT(AXQueryInterface_IObjectSafety);
1484     SET_EXPECT(AXGetInterfaceSafetyOptions);
1485     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1486     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1487             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1488     CHECK_CALLED(AXQueryInterface_IActiveScript);
1489     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1490     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1491     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1492     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1493
1494     if(skip_loadobject_tests)
1495         return;
1496
1497     cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1498     ax_objsafe = FALSE;
1499     SET_EXPECT(AXQueryInterface_IActiveScript);
1500     SET_EXPECT(AXQueryInterface_IObjectSafety);
1501     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1502             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1503     CHECK_CALLED(AXQueryInterface_IActiveScript);
1504     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1505     check_custom_policy(hres, ppolicy, policy_size, policy_load);
1506
1507     ax_objsafe = TRUE;
1508     SET_EXPECT(AXQueryInterface_IActiveScript);
1509     SET_EXPECT(AXQueryInterface_IObjectSafety);
1510     SET_EXPECT(AXGetInterfaceSafetyOptions);
1511     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1512     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1513     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1514             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1515     CHECK_CALLED(AXQueryInterface_IActiveScript);
1516     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1517     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1518     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1519     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1520     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1521 }
1522
1523 static void test_security(void)
1524 {
1525     IInternetHostSecurityManager *sec_mgr;
1526     IServiceProvider *sp;
1527     DWORD policy, policy_size;
1528     struct CONFIRMSAFETY cs;
1529     BYTE *ppolicy;
1530     HRESULT hres;
1531
1532     hres = IActiveScriptSite_QueryInterface(site, &IID_IServiceProvider, (void**)&sp);
1533     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1534
1535     hres = IServiceProvider_QueryService(sp, &SID_SInternetHostSecurityManager,
1536             &IID_IInternetHostSecurityManager, (void**)&sec_mgr);
1537     IServiceProvider_Release(sp);
1538     ok(hres == S_OK, "QueryService failed: %08x\n", hres);
1539
1540     hres = IInternetHostSecurityManager_ProcessUrlAction(sec_mgr, URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy),
1541                                                          (BYTE*)&CLSID_TestActiveX, sizeof(CLSID), 0, 0);
1542     ok(hres == S_OK, "ProcessUrlAction failed: %08x\n", hres);
1543     ok(policy == URLPOLICY_ALLOW, "policy = %x\n", policy);
1544
1545     cs.clsid = CLSID_TestActiveX;
1546     cs.pUnk = (IUnknown*)&AXObjectSafety;
1547     cs.dwFlags = 0;
1548
1549     ax_objsafe = TRUE;
1550     SET_EXPECT(AXQueryInterface_IActiveScript);
1551     SET_EXPECT(AXQueryInterface_IObjectSafety);
1552     SET_EXPECT(AXGetInterfaceSafetyOptions);
1553     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1554     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1555             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1556     CHECK_CALLED(AXQueryInterface_IActiveScript);
1557     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1558     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1559     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1560     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1561
1562     cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1563     SET_EXPECT(AXQueryInterface_IActiveScript);
1564     SET_EXPECT(AXQueryInterface_IObjectSafety);
1565     SET_EXPECT(AXGetInterfaceSafetyOptions);
1566     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1567     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1568     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1569             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1570     CHECK_CALLED(AXQueryInterface_IActiveScript);
1571     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1572     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1573     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1574     if(called_AXSetInterfaceSafetyOptions_IDispatch_data) {
1575         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1576     }else {
1577         win_skip("CONFIRMSAFETYACTION_LOADOBJECT flag not supported\n");
1578         skip_loadobject_tests = TRUE;
1579         CLEAR_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1580     }
1581     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1582
1583     cs.dwFlags = 0;
1584     ax_objsafe = FALSE;
1585     SET_EXPECT(AXQueryInterface_IActiveScript);
1586     SET_EXPECT(AXQueryInterface_IObjectSafety);
1587     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1588             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1589     CHECK_CALLED(AXQueryInterface_IActiveScript);
1590     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1591     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1592
1593     if(!skip_loadobject_tests) {
1594         cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1595         ax_objsafe = FALSE;
1596         SET_EXPECT(AXQueryInterface_IActiveScript);
1597         SET_EXPECT(AXQueryInterface_IObjectSafety);
1598         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1599                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1600         CHECK_CALLED(AXQueryInterface_IActiveScript);
1601         CHECK_CALLED(AXQueryInterface_IObjectSafety);
1602         check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1603     }
1604
1605     if(set_safe_reg(TRUE, FALSE)) {
1606         test_security_reg(sec_mgr, URLPOLICY_ALLOW, URLPOLICY_DISALLOW);
1607
1608         set_safe_reg(FALSE, TRUE);
1609         test_security_reg(sec_mgr, URLPOLICY_DISALLOW, URLPOLICY_DISALLOW);
1610
1611         set_safe_reg(TRUE, TRUE);
1612         test_security_reg(sec_mgr, URLPOLICY_ALLOW, URLPOLICY_ALLOW);
1613
1614         set_safe_reg(FALSE, FALSE);
1615     }else {
1616         skip("Could not set safety registry\n");
1617     }
1618
1619     ax_objsafe = TRUE;
1620
1621     cs.dwFlags = 0;
1622     ax_setopt_dispex_hres = E_NOINTERFACE;
1623     SET_EXPECT(AXQueryInterface_IActiveScript);
1624     SET_EXPECT(AXQueryInterface_IObjectSafety);
1625     SET_EXPECT(AXGetInterfaceSafetyOptions);
1626     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1627     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1628     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1629             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1630     CHECK_CALLED(AXQueryInterface_IActiveScript);
1631     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1632     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1633     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1634     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1635     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1636
1637     ax_setopt_dispex_hres = E_FAIL;
1638     ax_setopt_disp_caller_hres = E_NOINTERFACE;
1639     SET_EXPECT(AXQueryInterface_IActiveScript);
1640     SET_EXPECT(AXQueryInterface_IObjectSafety);
1641     SET_EXPECT(AXGetInterfaceSafetyOptions);
1642     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1643     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1644     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1645             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1646     CHECK_CALLED(AXQueryInterface_IActiveScript);
1647     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1648     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1649     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1650     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1651     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1652
1653     if(!skip_loadobject_tests) {
1654         cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1655         ax_setopt_dispex_hres = E_FAIL;
1656         ax_setopt_disp_caller_hres = E_NOINTERFACE;
1657         SET_EXPECT(AXQueryInterface_IActiveScript);
1658         SET_EXPECT(AXQueryInterface_IObjectSafety);
1659         SET_EXPECT(AXGetInterfaceSafetyOptions);
1660         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1661         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1662         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1663                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1664         CHECK_CALLED(AXQueryInterface_IActiveScript);
1665         CHECK_CALLED(AXQueryInterface_IObjectSafety);
1666         CHECK_CALLED(AXGetInterfaceSafetyOptions);
1667         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller_secmgr);
1668         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1669         check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1670     }
1671
1672     cs.dwFlags = 0;
1673     ax_setopt_dispex_hres = E_FAIL;
1674     ax_setopt_disp_caller_hres = S_OK;
1675     ax_getopt_hres = E_NOINTERFACE;
1676     SET_EXPECT(AXQueryInterface_IActiveScript);
1677     SET_EXPECT(AXQueryInterface_IObjectSafety);
1678     SET_EXPECT(AXGetInterfaceSafetyOptions);
1679     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1680     SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1681     hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1682             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1683     CHECK_CALLED(AXQueryInterface_IActiveScript);
1684     CHECK_CALLED(AXQueryInterface_IObjectSafety);
1685     CHECK_CALLED(AXGetInterfaceSafetyOptions);
1686     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1687     CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1688     check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_ALLOW);
1689
1690     if(!skip_loadobject_tests) {
1691         cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
1692         ax_setopt_dispex_hres = E_FAIL;
1693         ax_setopt_disp_caller_hres = S_OK;
1694         ax_setopt_disp_data_hres = E_FAIL;
1695         ax_getopt_hres = E_NOINTERFACE;
1696         SET_EXPECT(AXQueryInterface_IActiveScript);
1697         SET_EXPECT(AXQueryInterface_IObjectSafety);
1698         SET_EXPECT(AXGetInterfaceSafetyOptions);
1699         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1700         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_caller);
1701         SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch_data);
1702         hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1703                 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1704         CHECK_CALLED(AXQueryInterface_IActiveScript);
1705         CHECK_CALLED(AXQueryInterface_IObjectSafety);
1706         CHECK_CALLED(AXGetInterfaceSafetyOptions);
1707         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx_caller);
1708         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_caller);
1709         CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch_data);
1710         check_custom_policy(hres, ppolicy, policy_size, URLPOLICY_DISALLOW);
1711     }
1712
1713     IInternetHostSecurityManager_Release(sec_mgr);
1714 }
1715
1716 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
1717 {
1718     *ppv = NULL;
1719     ok(0, "unexpected call\n");
1720     return E_NOINTERFACE;
1721 }
1722
1723 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
1724 {
1725     return 2;
1726 }
1727
1728 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
1729 {
1730     return 1;
1731 }
1732
1733 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
1734         VARIANT *pvarIndex, VARIANT *pvarValue)
1735 {
1736     ok(0, "unexpected call\n");
1737     return E_NOTIMPL;
1738 }
1739
1740 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
1741         VARIANT *pvarIndex, VARIANT *pvarValue)
1742 {
1743     switch(dwProperty) {
1744     case SCRIPTPROP_HACK_TRIDENTEVENTSINK:
1745         CHECK_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
1746         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1747         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
1748         break;
1749     case SCRIPTPROP_INVOKEVERSIONING:
1750         CHECK_EXPECT(SetProperty_INVOKEVERSIONING);
1751         ok(V_VT(pvarValue) == VT_I4, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1752         ok(V_I4(pvarValue) == 1, "V_I4(pvarValue)=%d\n", V_I4(pvarValue));
1753         break;
1754     case SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION:
1755         CHECK_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
1756         ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1757         ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
1758         break;
1759     case 0x70000003: /* Undocumented property set by IE10 */
1760         return E_NOTIMPL;
1761     default:
1762         ok(0, "unexpected property %x\n", dwProperty);
1763         return E_NOTIMPL;
1764     }
1765
1766     ok(!pvarIndex, "pvarIndex != NULL\n");
1767     ok(pvarValue != NULL, "pvarValue == NULL\n");
1768
1769     return S_OK;
1770 }
1771
1772 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
1773     ActiveScriptProperty_QueryInterface,
1774     ActiveScriptProperty_AddRef,
1775     ActiveScriptProperty_Release,
1776     ActiveScriptProperty_GetProperty,
1777     ActiveScriptProperty_SetProperty
1778 };
1779
1780 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
1781
1782 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
1783 {
1784     *ppv = NULL;
1785     ok(0, "unexpected call\n");
1786     return E_NOINTERFACE;
1787 }
1788
1789 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
1790 {
1791     return 2;
1792 }
1793
1794 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
1795 {
1796     return 1;
1797 }
1798
1799 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
1800         LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
1801         LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
1802         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
1803 {
1804     ok(0, "unexpected call\n");
1805     return E_NOTIMPL;
1806 }
1807
1808 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
1809     ActiveScriptParseProcedure_QueryInterface,
1810     ActiveScriptParseProcedure_AddRef,
1811     ActiveScriptParseProcedure_Release,
1812     ActiveScriptParseProcedure_ParseProcedureText
1813 };
1814
1815 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
1816
1817 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
1818 {
1819     *ppv = NULL;
1820     ok(0, "unexpected call\n");
1821     return E_NOINTERFACE;
1822 }
1823
1824 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
1825 {
1826     return 2;
1827 }
1828
1829 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
1830 {
1831     return 1;
1832 }
1833
1834 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
1835 {
1836     CHECK_EXPECT(InitNew);
1837     return S_OK;
1838 }
1839
1840 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
1841         LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
1842         LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
1843         CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
1844         BSTR *pbstrName, EXCEPINFO *pexcepinfo)
1845 {
1846     ok(0, "unexpected call\n");
1847     return E_NOTIMPL;
1848 }
1849
1850 static HRESULT dispex_propput(IDispatchEx *obj, DISPID id, DWORD flags, VARIANT *var, IServiceProvider *caller_sp)
1851 {
1852     DISPID propput_arg = DISPID_PROPERTYPUT;
1853     DISPPARAMS dp = {var, &propput_arg, 1, 1};
1854     EXCEPINFO ei = {0};
1855
1856     return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT|flags, &dp, NULL, &ei, caller_sp);
1857 }
1858
1859 static HRESULT dispex_propget(IDispatchEx *obj, DISPID id, VARIANT *res, IServiceProvider *caller_sp)
1860 {
1861     DISPPARAMS dp = {NULL};
1862     EXCEPINFO ei = {0};
1863
1864     return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, res, &ei, caller_sp);
1865 }
1866
1867 static void test_func(IDispatchEx *obj)
1868 {
1869     DISPID id;
1870     IDispatchEx *dispex;
1871     IDispatch *disp;
1872     EXCEPINFO ei;
1873     DISPPARAMS dp;
1874     BSTR str;
1875     VARIANT var;
1876     HRESULT hres;
1877
1878     str = a2bstr("toString");
1879     hres = IDispatchEx_GetDispID(obj, str, fdexNameCaseSensitive, &id);
1880     SysFreeString(str);
1881     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1882     ok(id == DISPID_IOMNAVIGATOR_TOSTRING, "id = %x\n", id);
1883
1884     memset(&dp, 0, sizeof(dp));
1885     memset(&ei, 0, sizeof(ei));
1886     VariantInit(&var);
1887     hres = IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1888     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1889     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
1890     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(var) == NULL\n");
1891     disp = V_DISPATCH(&var);
1892
1893     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1894     IDispatch_Release(disp);
1895     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
1896
1897     /* FIXME: Test InvokeEx(DISPATCH_METHOD) */
1898
1899     memset(&dp, 0, sizeof(dp));
1900     memset(&ei, 0, sizeof(ei));
1901     VariantInit(&var);
1902     hres = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &var, &ei, NULL);
1903     ok(hres == S_OK || broken(E_ACCESSDENIED), "InvokeEx failed: %08x\n", hres);
1904     if(SUCCEEDED(hres)) {
1905         ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
1906         ok(!strcmp_wa(V_BSTR(&var), "[object]"), "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
1907         VariantClear(&var);
1908     }
1909
1910     V_VT(&var) = VT_I4;
1911     V_I4(&var) = 100;
1912     hres = dispex_propput(obj, id, 0, &var, NULL);
1913     ok(hres == E_NOTIMPL, "InvokeEx failed: %08x\n", hres);
1914
1915     IDispatchEx_Release(dispex);
1916 }
1917
1918 static void test_nextdispid(IDispatchEx *dispex)
1919 {
1920     DISPID last_id = DISPID_STARTENUM, id, dyn_id;
1921     BSTR name;
1922     VARIANT var;
1923     HRESULT hres;
1924
1925     name = a2bstr("dynVal");
1926     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseSensitive|fdexNameEnsure, &dyn_id);
1927     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1928     SysFreeString(name);
1929
1930     V_VT(&var) = VT_EMPTY;
1931     hres = dispex_propput(dispex, dyn_id, 0, &var, NULL);
1932     ok(hres == S_OK, "dispex_propput failed: %08x\n", hres);
1933
1934     while(last_id != dyn_id) {
1935         hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, last_id, &id);
1936         ok(hres == S_OK, "GetNextDispID returned: %08x\n", hres);
1937         ok(id != DISPID_STARTENUM, "id == DISPID_STARTENUM\n");
1938         ok(id != DISPID_IOMNAVIGATOR_TOSTRING, "id == DISPID_IOMNAVIGATOR_TOSTRING\n");
1939
1940         hres = IDispatchEx_GetMemberName(dispex, id, &name);
1941         ok(hres == S_OK, "GetMemberName failed: %08x\n", hres);
1942
1943         if(id == dyn_id)
1944             ok(!strcmp_wa(name, "dynVal"), "name = %s\n", wine_dbgstr_w(name));
1945         else if(id == DISPID_IOMNAVIGATOR_PLATFORM)
1946             ok(!strcmp_wa(name, "platform"), "name = %s\n", wine_dbgstr_w(name));
1947
1948         SysFreeString(name);
1949         last_id = id;
1950     }
1951
1952     hres = IDispatchEx_GetNextDispID(dispex, 0, id, &id);
1953     ok(hres == S_FALSE, "GetNextDispID returned: %08x\n", hres);
1954     ok(id == DISPID_STARTENUM, "id != DISPID_STARTENUM\n");
1955 }
1956
1957 static void test_global_id(void)
1958 {
1959     VARIANT var;
1960     DISPPARAMS dp;
1961     EXCEPINFO ei;
1962     BSTR tmp;
1963     DISPID id;
1964     HRESULT hres;
1965
1966     SET_EXPECT(GetScriptDispatch);
1967     SET_EXPECT(script_divid_d);
1968     tmp = a2bstr("divid");
1969     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1970     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1971     SysFreeString(tmp);
1972     CHECK_CALLED(GetScriptDispatch);
1973     CHECK_CALLED(script_divid_d);
1974
1975     VariantInit(&var);
1976     memset(&ei, 0, sizeof(ei));
1977     memset(&dp, 0, sizeof(dp));
1978     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1979     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1980     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var) = %d\n", V_VT(&var));
1981     VariantClear(&var);
1982 }
1983
1984 static void test_arg_conv(IHTMLWindow2 *window)
1985 {
1986     IHTMLDocument2 *doc;
1987     IDispatchEx *dispex;
1988     IHTMLElement *elem;
1989     VARIANT v;
1990     HRESULT hres;
1991
1992     hres = IHTMLWindow2_get_document(window, &doc);
1993     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1994
1995     hres = IHTMLDocument2_get_body(doc, &elem);
1996     IHTMLDocument2_Release(doc);
1997     ok(hres == S_OK, "get_body failed: %08x\n", hres);
1998
1999     hres = IHTMLElement_QueryInterface(elem, &IID_IDispatchEx, (void**)&dispex);
2000     IHTMLElement_Release(elem);
2001     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
2002
2003     SET_EXPECT(QS_VariantConversion);
2004     SET_EXPECT(ChangeType);
2005     V_VT(&v) = VT_I4;
2006     V_I4(&v) = 0xf0f0f0;
2007     hres = dispex_propput(dispex, DISPID_IHTMLBODYELEMENT_BACKGROUND, 0, &v, &caller_sp);
2008     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2009     CHECK_CALLED(QS_VariantConversion);
2010     CHECK_CALLED(ChangeType);
2011
2012     V_VT(&v) = VT_EMPTY;
2013     hres = dispex_propget(dispex, DISPID_IHTMLBODYELEMENT_BGCOLOR, &v, &caller_sp);
2014     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2015     ok(V_VT(&v) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&v));
2016     ok(!V_BSTR(&v), "V_BSTR(&var) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
2017
2018     IDispatchEx_Release(dispex);
2019 }
2020
2021 #define test_elem_disabled(a,b) _test_elem_disabled(__LINE__,a,b)
2022 static void _test_elem_disabled(unsigned line, IHTMLElement *elem, VARIANT_BOOL exb)
2023 {
2024     IHTMLElement3 *elem3;
2025     VARIANT_BOOL b = 100;
2026     HRESULT hres;
2027
2028     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLElement3, (void**)&elem3);
2029     ok_(__FILE__,line)(hres == S_OK, "Could not get IHTMLElement3 iface: %08x\n", hres);
2030
2031     hres = IHTMLElement3_get_disabled(elem3, &b);
2032     ok_(__FILE__,line)(hres == S_OK, "get_disabled failed: %08x\n", hres);
2033     ok_(__FILE__,line)(b == exb, "disabled = %x, expected %x\n", b, exb);
2034
2035     IHTMLElement3_Release(elem3);
2036 }
2037
2038 static void test_default_arg_conv(IHTMLWindow2 *window)
2039 {
2040     IHTMLDocument2 *doc;
2041     IDispatchEx *dispex;
2042     IHTMLElement *elem;
2043     VARIANT v;
2044     HRESULT hres;
2045
2046     hres = IHTMLWindow2_get_document(window, &doc);
2047     ok(hres == S_OK, "get_document failed: %08x\n", hres);
2048
2049     hres = IHTMLDocument2_get_body(doc, &elem);
2050     IHTMLDocument2_Release(doc);
2051     ok(hres == S_OK, "get_body failed: %08x\n", hres);
2052
2053     hres = IHTMLElement_QueryInterface(elem, &IID_IDispatchEx, (void**)&dispex);
2054     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
2055
2056     test_elem_disabled(elem, VARIANT_FALSE);
2057
2058     V_VT(&v) = VT_BSTR;
2059     V_BSTR(&v) = a2bstr("test");
2060     hres = dispex_propput(dispex, DISPID_IHTMLELEMENT3_DISABLED, 0, &v, NULL);
2061     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2062     SysFreeString(V_BSTR(&v));
2063
2064     test_elem_disabled(elem, VARIANT_TRUE);
2065
2066     V_VT(&v) = VT_I4;
2067     V_BSTR(&v) = 0;
2068     hres = dispex_propput(dispex, DISPID_IHTMLELEMENT3_DISABLED, 0, &v, NULL);
2069     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2070
2071     test_elem_disabled(elem, VARIANT_FALSE);
2072
2073     IHTMLElement_Release(elem);
2074     IDispatchEx_Release(dispex);
2075 }
2076
2077 static void test_ui(void)
2078 {
2079     IActiveScriptSiteUIControl *ui_control;
2080     SCRIPTUICHANDLING uic_handling = 10;
2081     HRESULT hres;
2082
2083     hres = IActiveScriptSite_QueryInterface(site, &IID_IActiveScriptSiteUIControl, (void**)&ui_control);
2084     if(hres == E_NOINTERFACE) {
2085         win_skip("IActiveScriptSiteUIControl not supported\n");
2086         return;
2087     }
2088     ok(hres == S_OK, "Could not get IActiveScriptSiteUIControl: %08x\n", hres);
2089
2090     hres = IActiveScriptSiteUIControl_GetUIBehavior(ui_control, SCRIPTUICITEM_MSGBOX, &uic_handling);
2091     ok(hres == S_OK, "GetUIBehavior failed: %08x\n", hres);
2092     ok(uic_handling == SCRIPTUICHANDLING_ALLOW, "uic_handling = %d\n", uic_handling);
2093
2094     IActiveScriptSiteUIControl_Release(ui_control);
2095 }
2096
2097 static void test_sp(void)
2098 {
2099     IServiceProvider *sp;
2100     IUnknown *unk;
2101     HRESULT hres;
2102
2103     hres = IActiveScriptSite_QueryInterface(site, &IID_IServiceProvider, (void**)&sp);
2104     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
2105
2106     hres = IServiceProvider_QueryService(sp, &SID_SContainerDispatch, &IID_IHTMLDocument, (void**)&unk);
2107     ok(hres == S_OK, "Could not get SID_SContainerDispatch service: %08x\n", hres);
2108     IUnknown_Release(unk);
2109
2110     IServiceProvider_Release(sp);
2111 }
2112
2113 static void test_script_run(void)
2114 {
2115     IDispatchEx *document, *dispex;
2116     IHTMLWindow2 *window;
2117     IOmNavigator *navigator;
2118     IUnknown *unk;
2119     VARIANT var, arg;
2120     DISPPARAMS dp;
2121     EXCEPINFO ei;
2122     DISPID id;
2123     BSTR tmp;
2124     HRESULT hres;
2125
2126     static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
2127     static const WCHAR testW[] = {'t','e','s','t',0};
2128     static const WCHAR funcW[] = {'f','u','n','c',0};
2129
2130     SET_EXPECT(GetScriptDispatch);
2131
2132     tmp = SysAllocString(documentW);
2133     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2134     SysFreeString(tmp);
2135     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
2136     ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
2137
2138     CHECK_CALLED(GetScriptDispatch);
2139
2140     VariantInit(&var);
2141     memset(&dp, 0, sizeof(dp));
2142     memset(&ei, 0, sizeof(ei));
2143
2144     hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2145     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2146     ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
2147     ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
2148
2149     hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
2150     VariantClear(&var);
2151     ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
2152
2153     tmp = SysAllocString(testW);
2154     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
2155     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
2156     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
2157     ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
2158     SysFreeString(tmp);
2159
2160     id = 0;
2161     tmp = SysAllocString(testW);
2162     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
2163     SysFreeString(tmp);
2164     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
2165     ok(id, "id == 0\n");
2166
2167     V_VT(&var) = VT_I4;
2168     V_I4(&var) = 100;
2169     hres = dispex_propput(document, id, 0, &var, NULL);
2170     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2171
2172     tmp = SysAllocString(testW);
2173     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
2174     SysFreeString(tmp);
2175     ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
2176
2177     hres = IDispatchEx_DeleteMemberByDispID(document, id);
2178     ok(hres == E_NOTIMPL, "DeleteMemberByDispID failed = %08x\n", hres);
2179
2180     VariantInit(&var);
2181     memset(&dp, 0, sizeof(dp));
2182     memset(&ei, 0, sizeof(ei));
2183     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2184     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2185     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2186     ok(V_I4(&var) == 100, "V_I4(&var) = %d\n", V_I4(&var));
2187
2188     V_VT(&var) = VT_I4;
2189     V_I4(&var) = 200;
2190     hres = dispex_propput(document, id, DISPATCH_PROPERTYPUTREF, &var, NULL);
2191     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2192
2193     VariantInit(&var);
2194     memset(&dp, 0, sizeof(dp));
2195     memset(&ei, 0, sizeof(ei));
2196     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2197     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2198     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2199     ok(V_I4(&var) == 200, "V_I4(&var) = %d\n", V_I4(&var));
2200
2201     memset(&dp, 0, sizeof(dp));
2202     memset(&ei, 0, sizeof(ei));
2203     V_VT(&var) = VT_I4;
2204     V_I4(&var) = 300;
2205     dp.cArgs = 1;
2206     dp.rgvarg = &var;
2207     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
2208     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2209
2210     VariantInit(&var);
2211     memset(&dp, 0, sizeof(dp));
2212     memset(&ei, 0, sizeof(ei));
2213     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2214     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2215     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2216     ok(V_I4(&var) == 300, "V_I4(&var) = %d\n", V_I4(&var));
2217
2218     V_VT(&var) = VT_BSTR;
2219     V_BSTR(&var) = NULL;
2220     dispex_propput(document, id, 0, &var, NULL);
2221
2222     VariantInit(&var);
2223     memset(&dp, 0, sizeof(dp));
2224     memset(&ei, 0, sizeof(ei));
2225     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
2226     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2227     ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
2228     ok(!V_BSTR(&var), "V_BSTR(&var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
2229
2230     unk = (void*)0xdeadbeef;
2231     hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
2232     ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
2233     ok(!unk, "unk=%p, expected NULL\n", unk);
2234
2235     id = 0;
2236     tmp = SysAllocString(funcW);
2237     hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
2238     SysFreeString(tmp);
2239     ok(hres == S_OK, "GetDispID(func) failed: %08x\n", hres);
2240     ok(id, "id == 0\n");
2241
2242     dp.cArgs = 1;
2243     dp.rgvarg = &var;
2244     dp.cNamedArgs = 0;
2245     dp.rgdispidNamedArgs = NULL;
2246     V_VT(&var) = VT_DISPATCH;
2247     V_DISPATCH(&var) = (IDispatch*)&funcDisp;
2248     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
2249     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2250
2251     VariantInit(&var);
2252     memset(&dp, 0, sizeof(dp));
2253     memset(&ei, 0, sizeof(ei));
2254     V_VT(&arg) = VT_BOOL;
2255     V_BOOL(&arg) = VARIANT_TRUE;
2256     dp.cArgs = 1;
2257     dp.rgvarg = &arg;
2258
2259     SET_EXPECT(funcDisp);
2260     hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_FUNC, &dp, &var, &ei, NULL);
2261     CHECK_CALLED(funcDisp);
2262
2263     ok(hres == S_OK, "InvokeEx(INVOKE_FUNC) failed: %08x\n", hres);
2264     ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
2265     ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
2266
2267     IDispatchEx_Release(document);
2268
2269     hres = IDispatchEx_QueryInterface(window_dispex, &IID_IHTMLWindow2, (void**)&window);
2270     ok(hres == S_OK, "Could not get IHTMLWindow2 iface: %08x\n", hres);
2271
2272     hres = IHTMLWindow2_get_navigator(window, &navigator);
2273     ok(hres == S_OK, "get_navigator failed: %08x\n", hres);
2274
2275     hres = IOmNavigator_QueryInterface(navigator, &IID_IDispatchEx, (void**)&dispex);
2276     IOmNavigator_Release(navigator);
2277     ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
2278
2279     test_func(dispex);
2280     test_nextdispid(dispex);
2281
2282     test_arg_conv(window);
2283     test_default_arg_conv(window);
2284     IHTMLWindow2_Release(window);
2285
2286     tmp = a2bstr("test");
2287     hres = IDispatchEx_DeleteMemberByName(dispex, tmp, fdexNameCaseSensitive);
2288     ok(hres == E_NOTIMPL, "DeleteMemberByName failed: %08x\n", hres);
2289
2290     IDispatchEx_Release(dispex);
2291
2292     script_disp = (IDispatch*)&scriptDisp;
2293
2294     SET_EXPECT(GetScriptDispatch);
2295     SET_EXPECT(script_testprop_d);
2296     tmp = a2bstr("testProp");
2297     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2298     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2299     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
2300     CHECK_CALLED(GetScriptDispatch);
2301     CHECK_CALLED(script_testprop_d);
2302     SysFreeString(tmp);
2303
2304     tmp = a2bstr("testProp");
2305     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
2306     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2307     ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
2308     SysFreeString(tmp);
2309
2310     SET_EXPECT(GetScriptDispatch);
2311     SET_EXPECT(script_testprop_i);
2312     memset(&ei, 0, sizeof(ei));
2313     memset(&dp, 0, sizeof(dp));
2314     hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
2315     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
2316     ok(V_VT(&var) == VT_NULL, "V_VT(var) = %d\n", V_VT(&var));
2317     CHECK_CALLED(GetScriptDispatch);
2318     CHECK_CALLED(script_testprop_i);
2319
2320     SET_EXPECT(GetScriptDispatch);
2321     SET_EXPECT(script_testprop2_d);
2322     tmp = a2bstr("testProp2");
2323     hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
2324     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
2325     ok(id != DISPID_SCRIPT_TESTPROP2, "id == DISPID_SCRIPT_TESTPROP2\n");
2326     CHECK_CALLED(GetScriptDispatch);
2327     CHECK_CALLED(script_testprop2_d);
2328     SysFreeString(tmp);
2329
2330     tmp = a2bstr("test");
2331     hres = IDispatchEx_DeleteMemberByName(window_dispex, tmp, fdexNameCaseSensitive);
2332     ok(hres == E_NOTIMPL, "DeleteMemberByName failed: %08x\n", hres);
2333
2334     test_global_id();
2335
2336     test_security();
2337     test_ui();
2338     test_sp();
2339 }
2340
2341 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
2342         LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
2343         LPCOLESTR pstrDelimiter, CTXARG_T dwSourceContextCookie, ULONG ulStartingLine,
2344         DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
2345 {
2346     ok(pvarResult != NULL, "pvarResult == NULL\n");
2347     ok(pexcepinfo != NULL, "pexcepinfo == NULL\n");
2348
2349     if(!strcmp_wa(pstrCode, "execScript call")) {
2350         CHECK_EXPECT(ParseScriptText_execScript);
2351         ok(!pstrItemName, "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2352         ok(!strcmp_wa(pstrDelimiter, "\""), "pstrDelimiter = %s\n", wine_dbgstr_w(pstrDelimiter));
2353         ok(dwFlags == SCRIPTTEXT_ISVISIBLE, "dwFlags = %x\n", dwFlags);
2354
2355         V_VT(pvarResult) = VT_I4;
2356         V_I4(pvarResult) = 10;
2357         return S_OK;
2358     }else if(!strcmp_wa(pstrCode, "simple script")) {
2359         CHECK_EXPECT(ParseScriptText_script);
2360         ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2361         ok(!strcmp_wa(pstrDelimiter, "</SCRIPT>"), "pstrDelimiter = %s\n", wine_dbgstr_w(pstrDelimiter));
2362         ok(dwFlags == (SCRIPTTEXT_ISVISIBLE|SCRIPTTEXT_HOSTMANAGESSOURCE), "dwFlags = %x\n", dwFlags);
2363
2364         test_script_run();
2365         return S_OK;
2366     }
2367
2368     ok(0, "unexpected script %s\n", wine_dbgstr_w(pstrCode));
2369     return E_FAIL;
2370 }
2371
2372 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
2373     ActiveScriptParse_QueryInterface,
2374     ActiveScriptParse_AddRef,
2375     ActiveScriptParse_Release,
2376     ActiveScriptParse_InitNew,
2377     ActiveScriptParse_AddScriptlet,
2378     ActiveScriptParse_ParseScriptText
2379 };
2380
2381 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
2382
2383 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
2384 {
2385     *ppv = NULL;
2386
2387     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
2388         *ppv = iface;
2389         return S_OK;
2390     }
2391
2392     if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
2393         *ppv = &ActiveScriptParse;
2394         return S_OK;
2395     }
2396
2397     if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
2398         *ppv = &ActiveScriptParseProcedure;
2399         return S_OK;
2400     }
2401
2402     if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
2403         *ppv = &ActiveScriptProperty;
2404         return S_OK;
2405     }
2406
2407     if(IsEqualGUID(&IID_IObjectSafety, riid)) {
2408         *ppv = &ObjectSafety;
2409         return S_OK;
2410     }
2411
2412     if(IsEqualGUID(&IID_IActiveScriptDebug, riid))
2413         return E_NOINTERFACE;
2414
2415     trace("QI(%s)\n", wine_dbgstr_guid(riid));
2416     return E_NOINTERFACE;
2417 }
2418
2419 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
2420 {
2421     return 2;
2422 }
2423
2424 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
2425 {
2426     return 1;
2427 }
2428
2429 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
2430 {
2431     IActiveScriptSiteInterruptPoll *poll;
2432     IActiveScriptSiteDebug *debug;
2433     IServiceProvider *service;
2434     ICanHandleException *canexpection;
2435     LCID lcid;
2436     HRESULT hres;
2437
2438     CHECK_EXPECT(SetScriptSite);
2439
2440     ok(pass != NULL, "pass == NULL\n");
2441
2442     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
2443     ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
2444     if(FAILED(hres))
2445         IActiveScriptSiteInterruptPoll_Release(poll);
2446
2447     hres = IActiveScriptSite_GetLCID(pass, &lcid);
2448     ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
2449
2450     hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
2451     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
2452
2453     hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
2454     ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
2455     if(SUCCEEDED(hres))
2456         IActiveScriptSiteDebug_Release(debug);
2457
2458     hres = IActiveScriptSite_QueryInterface(pass, &IID_ICanHandleException, (void**)&canexpection);
2459     ok(hres == E_NOINTERFACE, "Could not get IID_ICanHandleException interface: %08x\n", hres);
2460
2461     hres = IActiveScriptSite_QueryInterface(pass, &IID_IServiceProvider, (void**)&service);
2462     ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
2463     if(SUCCEEDED(hres))
2464         IServiceProvider_Release(service);
2465
2466     site = pass;
2467     IActiveScriptSite_AddRef(site);
2468     return S_OK;
2469 }
2470
2471 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
2472                                             void **ppvObject)
2473 {
2474     ok(0, "unexpected call\n");
2475     return E_NOTIMPL;
2476 }
2477
2478 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
2479 {
2480     HRESULT hres;
2481
2482     switch(ss) {
2483     case SCRIPTSTATE_STARTED:
2484         CHECK_EXPECT(SetScriptState_STARTED);
2485         break;
2486     case SCRIPTSTATE_CONNECTED:
2487         CHECK_EXPECT(SetScriptState_CONNECTED);
2488         break;
2489     case SCRIPTSTATE_DISCONNECTED:
2490         CHECK_EXPECT(SetScriptState_DISCONNECTED);
2491         break;
2492     default:
2493         ok(0, "unexpected state %d\n", ss);
2494         return E_NOTIMPL;
2495     }
2496
2497     hres = IActiveScriptSite_OnStateChange(site, (state = ss));
2498     ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
2499
2500     return S_OK;
2501 }
2502
2503 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
2504 {
2505     CHECK_EXPECT(GetScriptState);
2506
2507     *pssState = state;
2508     return S_OK;
2509 }
2510
2511 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
2512 {
2513     CHECK_EXPECT(Close);
2514     return E_NOTIMPL;
2515 }
2516
2517 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
2518         LPCOLESTR pstrName, DWORD dwFlags)
2519 {
2520     IDispatch *disp;
2521     IUnknown *unk = NULL, *unk2;
2522     HRESULT hres;
2523
2524     static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
2525
2526     static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
2527
2528     CHECK_EXPECT(AddNamedItem);
2529
2530     ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", wine_dbgstr_w(pstrName));
2531     ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
2532
2533     hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
2534     ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
2535     ok(unk != NULL, "unk == NULL\n");
2536
2537     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2538     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
2539     if(SUCCEEDED(hres))
2540         IDispatch_Release(disp);
2541
2542     hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
2543     ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
2544     if(SUCCEEDED(hres))
2545         IUnknown_Release(unk2);
2546
2547     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
2548     ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
2549
2550     IUnknown_Release(unk);
2551     return S_OK;
2552 }
2553
2554 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
2555                                          DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
2556 {
2557     ok(0, "unexpected call\n");
2558     return E_NOTIMPL;
2559 }
2560
2561 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
2562                                                 IDispatch **ppdisp)
2563 {
2564     CHECK_EXPECT(GetScriptDispatch);
2565
2566     ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2567
2568     if(!script_disp)
2569         return E_NOTIMPL;
2570
2571     *ppdisp = script_disp;
2572     return S_OK;
2573 }
2574
2575 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
2576                                                        SCRIPTTHREADID *pstridThread)
2577 {
2578     ok(0, "unexpected call\n");
2579     return E_NOTIMPL;
2580 }
2581
2582 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
2583                                                 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
2584 {
2585     ok(0, "unexpected call\n");
2586     return E_NOTIMPL;
2587 }
2588
2589 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
2590         SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
2591 {
2592     ok(0, "unexpected call\n");
2593     return E_NOTIMPL;
2594 }
2595
2596 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
2597         SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
2598 {
2599     ok(0, "unexpected call\n");
2600     return E_NOTIMPL;
2601 }
2602
2603 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
2604 {
2605     ok(0, "unexpected call\n");
2606     return E_NOTIMPL;
2607 }
2608
2609 static const IActiveScriptVtbl ActiveScriptVtbl = {
2610     ActiveScript_QueryInterface,
2611     ActiveScript_AddRef,
2612     ActiveScript_Release,
2613     ActiveScript_SetScriptSite,
2614     ActiveScript_GetScriptSite,
2615     ActiveScript_SetScriptState,
2616     ActiveScript_GetScriptState,
2617     ActiveScript_Close,
2618     ActiveScript_AddNamedItem,
2619     ActiveScript_AddTypeLib,
2620     ActiveScript_GetScriptDispatch,
2621     ActiveScript_GetCurrentScriptThreadID,
2622     ActiveScript_GetScriptThreadID,
2623     ActiveScript_GetScriptThreadState,
2624     ActiveScript_InterruptScriptThread,
2625     ActiveScript_Clone
2626 };
2627
2628 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
2629
2630 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2631 {
2632     *ppv = NULL;
2633
2634     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
2635         *ppv = iface;
2636         return S_OK;
2637     }
2638
2639     if(IsEqualGUID(&IID_IMarshal, riid))
2640         return E_NOINTERFACE;
2641     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
2642         return E_NOINTERFACE;
2643
2644     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
2645     return E_NOTIMPL;
2646 }
2647
2648 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
2649 {
2650     return 2;
2651 }
2652
2653 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
2654 {
2655     return 1;
2656 }
2657
2658 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2659 {
2660     CHECK_EXPECT(CreateInstance);
2661
2662     ok(!outer, "outer = %p\n", outer);
2663     ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
2664     *ppv = &ActiveScript;
2665     return S_OK;
2666 }
2667
2668 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
2669 {
2670     ok(0, "unexpected call\n");
2671     return S_OK;
2672 }
2673
2674 static const IClassFactoryVtbl ClassFactoryVtbl = {
2675     ClassFactory_QueryInterface,
2676     ClassFactory_AddRef,
2677     ClassFactory_Release,
2678     ClassFactory_CreateInstance,
2679     ClassFactory_LockServer
2680 };
2681
2682 static IClassFactory script_cf = { &ClassFactoryVtbl };
2683
2684 static const char simple_script_str[] =
2685     "<html><head></head><body>"
2686     "<div id=\"divid\"></div>"
2687     "<script language=\"TestScript\">simple script</script>"
2688     "</body></html>";
2689
2690 static void test_exec_script(IHTMLDocument2 *doc, const char *codea, const char *langa)
2691 {
2692     IHTMLWindow2 *window;
2693     BSTR code, lang;
2694     VARIANT v;
2695     HRESULT hres;
2696
2697     hres = IHTMLDocument2_get_parentWindow(doc, &window);
2698     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
2699
2700     code = a2bstr(codea);
2701     lang = a2bstr(langa);
2702
2703     SET_EXPECT(ParseScriptText_execScript);
2704     hres = IHTMLWindow2_execScript(window, code, lang, &v);
2705     ok(hres == S_OK, "execScript failed: %08x\n", hres);
2706     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
2707     ok(V_I4(&v) == 10, "V_I4(v) = %d\n", V_I4(&v));
2708     CHECK_CALLED(ParseScriptText_execScript);
2709     SysFreeString(lang);
2710
2711     lang = a2bstr("invalid");
2712     V_VT(&v) = 100;
2713     hres = IHTMLWindow2_execScript(window, code, lang, &v);
2714     ok(hres == CO_E_CLASSSTRING, "execScript failed: %08x, expected CO_E_CLASSSTRING\n", hres);
2715     ok(V_VT(&v) == 100, "V_VT(v) = %d\n", V_VT(&v));
2716     SysFreeString(lang);
2717     SysFreeString(code);
2718
2719     IHTMLWindow2_Release(window);
2720 }
2721
2722 static void test_simple_script(void)
2723 {
2724     IHTMLDocument2 *doc;
2725
2726     doc = create_document();
2727     if(!doc)
2728         return;
2729
2730     SET_EXPECT(CreateInstance);
2731     SET_EXPECT(GetInterfaceSafetyOptions);
2732     SET_EXPECT(SetInterfaceSafetyOptions);
2733     SET_EXPECT(SetProperty_INVOKEVERSIONING); /* IE8 */
2734     SET_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
2735     SET_EXPECT(InitNew);
2736     SET_EXPECT(SetScriptSite);
2737     SET_EXPECT(GetScriptState);
2738     SET_EXPECT(SetScriptState_STARTED);
2739     SET_EXPECT(AddNamedItem);
2740     SET_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
2741     SET_EXPECT(ParseScriptText_script);
2742     SET_EXPECT(SetScriptState_CONNECTED);
2743
2744     load_doc(doc, simple_script_str);
2745
2746     CHECK_CALLED(CreateInstance);
2747     CHECK_CALLED(GetInterfaceSafetyOptions);
2748     CHECK_CALLED(SetInterfaceSafetyOptions);
2749     CHECK_CALLED_BROKEN(SetProperty_INVOKEVERSIONING); /* IE8 */
2750     CHECK_CALLED(SetProperty_HACK_TRIDENTEVENTSINK);
2751     CHECK_CALLED(InitNew);
2752     CHECK_CALLED(SetScriptSite);
2753     CHECK_CALLED(GetScriptState);
2754     CHECK_CALLED(SetScriptState_STARTED);
2755     CHECK_CALLED(AddNamedItem);
2756     CHECK_CALLED_BROKEN(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
2757     CHECK_CALLED(ParseScriptText_script);
2758     CHECK_CALLED(SetScriptState_CONNECTED);
2759
2760     test_exec_script(doc, "execScript call", "TestScript");
2761
2762     if(site)
2763         IActiveScriptSite_Release(site);
2764     if(window_dispex)
2765         IDispatchEx_Release(window_dispex);
2766
2767     SET_EXPECT(SetScriptState_DISCONNECTED);
2768     SET_EXPECT(Close);
2769
2770     IHTMLDocument2_Release(doc);
2771
2772     CHECK_CALLED(SetScriptState_DISCONNECTED);
2773     CHECK_CALLED(Close);
2774 }
2775
2776 static void run_js_script(const char *test_name)
2777 {
2778     WCHAR url[INTERNET_MAX_URL_LENGTH];
2779     char urlA[INTERNET_MAX_URL_LENGTH];
2780     IPersistMoniker *persist;
2781     IHTMLDocument2 *doc;
2782     IMoniker *mon;
2783     MSG msg;
2784     HRESULT hres;
2785
2786     static const char res[] = "res://";
2787
2788     trace("running %s...\n", test_name);
2789
2790     doc = create_document();
2791     if(!doc)
2792         return;
2793
2794     set_client_site(doc, TRUE);
2795     do_advise(doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2796
2797     lstrcpyA(urlA, res);
2798     GetModuleFileNameA(NULL, urlA + lstrlenA(res), sizeof(urlA) - lstrlenA(res));
2799     lstrcatA(urlA, "/");
2800     lstrcatA(urlA, test_name);
2801     MultiByteToWideChar(CP_ACP, 0, urlA, -1, url, sizeof(url)/sizeof(WCHAR));
2802
2803     hres = CreateURLMoniker(NULL, url, &mon);
2804     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
2805
2806     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&persist);
2807     ok(hres == S_OK, "Could not get IPersistMoniker iface: %08x\n", hres);
2808
2809     hres = IPersistMoniker_Load(persist, FALSE, mon, NULL, 0);
2810     ok(hres == S_OK, "Load failed: %08x\n", hres);
2811
2812     IMoniker_Release(mon);
2813     IPersistMoniker_Release(persist);
2814
2815     SET_EXPECT(external_success);
2816
2817     while(!called_external_success && GetMessageW(&msg, NULL, 0, 0)) {
2818         TranslateMessage(&msg);
2819         DispatchMessageW(&msg);
2820     }
2821
2822     CHECK_CALLED(external_success);
2823
2824     set_client_site(doc, FALSE);
2825     IHTMLDocument2_Release(doc);
2826 }
2827
2828 static void run_js_tests(void)
2829 {
2830     run_js_script("jstest.html");
2831     run_js_script("exectest.html");
2832     run_js_script("vbtest.html");
2833     run_js_script("events.html");
2834     run_js_script("nav_test.html");
2835 }
2836
2837 static BOOL init_registry(BOOL init)
2838 {
2839     return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
2840         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
2841                     NULL, init)
2842         && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
2843                     NULL, init);
2844 }
2845
2846 static BOOL register_script_engine(void)
2847 {
2848     DWORD regid;
2849     HRESULT hres;
2850
2851     if(!init_registry(TRUE)) {
2852         init_registry(FALSE);
2853         return FALSE;
2854     }
2855
2856     hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
2857                                  CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2858     ok(hres == S_OK, "Could not register script engine: %08x\n", hres);
2859
2860     return TRUE;
2861 }
2862
2863 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2864 {
2865     return DefWindowProcA(hwnd, msg, wParam, lParam);
2866 }
2867
2868 static HWND create_container_window(void)
2869 {
2870     static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
2871     static WNDCLASSEXA wndclass = {
2872         sizeof(WNDCLASSEXA),
2873         0,
2874         wnd_proc,
2875         0, 0, NULL, NULL, NULL, NULL, NULL,
2876         szHTMLDocumentTest,
2877         NULL
2878     };
2879
2880     RegisterClassExA(&wndclass);
2881     return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
2882             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2883             300, 300, NULL, NULL, NULL, NULL);
2884 }
2885
2886 START_TEST(script)
2887 {
2888     CoInitialize(NULL);
2889     container_hwnd = create_container_window();
2890
2891     if(winetest_interactive || ! is_ie_hardened()) {
2892         if(register_script_engine()) {
2893             test_simple_script();
2894             init_registry(FALSE);
2895         }else {
2896             skip("Could not register TestScript engine\n");
2897         }
2898         run_js_tests();
2899     }else {
2900         skip("IE running in Enhanced Security Configuration\n");
2901     }
2902
2903     DestroyWindow(container_hwnd);
2904     CoUninitialize();
2905 }