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