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