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

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