dlls/mshtml/tests/activex.c

   1 /*
   2  * Copyright 2010 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 "mshtml.h"
  30 #include "docobj.h"
  31 #include "hlink.h"
  32 #include "dispex.h"
  33 #include "mshtmhst.h"
  34 #include "activscp.h"
  35 #include "objsafe.h"
  36 #include "mshtmdid.h"
  37 #include "mshtml_test.h"
  38
  39 #include "initguid.h"
  40 #include "test_tlb.h"
  41
  42 #define DEFINE_EXPECT(func) \
  43     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  44
  45 #define SET_EXPECT(func) \
  46     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  47
  48 #define CHECK_EXPECT2(func) \
  49     do { \
  50         ok(expect_ ##func, "unexpected call " #func "\n"); \
  51         called_ ## func = TRUE; \
  52     }while(0)
  53
  54 #define CHECK_EXPECT(func) \
  55     do { \
  56         CHECK_EXPECT2(func); \
  57         expect_ ## func = FALSE; \
  58     }while(0)
  59
  60 #define CHECK_CALLED(func) \
  61     do { \
  62         ok(called_ ## func, "expected " #func "\n"); \
  63         expect_ ## func = called_ ## func = FALSE; \
  64     }while(0)
  65
  66 #define CLEAR_CALLED(func) \
  67     expect_ ## func = called_ ## func = FALSE
  68
  69 #undef GetClassInfo
  70
  71 DEFINE_EXPECT(CreateInstance);
  72 DEFINE_EXPECT(FreezeEvents_TRUE);
  73 DEFINE_EXPECT(FreezeEvents_FALSE);
  74 DEFINE_EXPECT(QuickActivate);
  75 DEFINE_EXPECT(IPersistPropertyBag_InitNew);
  76 DEFINE_EXPECT(IPersistPropertyBag_Load);
  77 DEFINE_EXPECT(Invoke_READYSTATE);
  78 DEFINE_EXPECT(Invoke_ENABLED);
  79 DEFINE_EXPECT(Invoke_VALID);
  80 DEFINE_EXPECT(Invoke_SECURITYCTX);
  81 DEFINE_EXPECT(Invoke_SCRIPTPROP);
  82 DEFINE_EXPECT(Invoke_SCRIPTCALL);
  83 DEFINE_EXPECT(GetIDsOfNames_scriptprop);
  84 DEFINE_EXPECT(DoVerb);
  85 DEFINE_EXPECT(SetExtent);
  86 DEFINE_EXPECT(GetExtent);
  87 DEFINE_EXPECT(SetClientSite);
  88 DEFINE_EXPECT(SetClientSite_NULL);
  89 DEFINE_EXPECT(Close);
  90 DEFINE_EXPECT(InPlaceObject_GetWindow);
  91 DEFINE_EXPECT(SetObjectRects);
  92 DEFINE_EXPECT(InPlaceDeactivate);
  93 DEFINE_EXPECT(UIDeactivate);
  94 DEFINE_EXPECT(QueryService_TestActiveX);
  95 DEFINE_EXPECT(GetMiscStatus);
  96 DEFINE_EXPECT(SetAdvise);
  97 DEFINE_EXPECT(GetViewStatus);
  98 DEFINE_EXPECT(QI_ITestActiveX);
  99 DEFINE_EXPECT(wrapped_AddRef);
 100 DEFINE_EXPECT(wrapped_Release);
 101 DEFINE_EXPECT(wrapped_func);
 102 DEFINE_EXPECT(OnAmbientPropertyChange_UNKNOWN);
 103 DEFINE_EXPECT(GetTypeInfo);
 104 DEFINE_EXPECT(GetClassInfo);
 105 DEFINE_EXPECT(FindConnectionPoint);
 106 DEFINE_EXPECT(Advise);
 107 DEFINE_EXPECT(Unadvise);
 108
 109 #define DISPID_SCRIPTPROP 1000
 110 #define DISPID_SCRIPTCALL 1001
 111
 112 enum {
 113     TEST_FLASH,
 114     TEST_NOQUICKACT,
 115     TEST_DISPONLY
 116 };
 117
 118 static ITypeInfo *actxtest_typeinfo, *class_typeinfo;
 119 static HWND container_hwnd, plugin_hwnd;
 120 static int plugin_behavior;
 121 static BOOL no_quickact;
 122 static LONG activex_refcnt;
 123
 124 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
 125
 126 static const GUID CLSID_TestActiveX =
 127     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
 128
 129 static const GUID IID_ITestActiveX =
 130     {0x178fc663,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
 131
 132 static const char object_ax_str[] =
 133     "<html><head></head><body>"
 134     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
 135     "<param name=\"param_name\" value=\"param_value\">"
 136     "<param name=\"num_param\" value=\"3\">"
 137     "</object>"
 138     "<script>"
 139     "objid.scriptCall();"
 140     "</script>"
 141     "</body></html>";
 142
 143 static const char event_binding_str[] =
 144     "<html><head></head><body>"
 145     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
 146     "<param name=\"param_name\" value=\"param_value\">"
 147     "<param name=\"num_param\" value=\"3\">"
 148     "</object>"
 149     "<script for=\"objid\" event=\"testfunc\">return 6;</script>"
 150     "<script for=\"objid\" event=\"testfunc2(x,y)\">return x+2*y;</script>"
 151     "</body></html>";
 152
 153 static REFIID pluginhost_iids[] = {
 154     &IID_IOleClientSite,
 155     &IID_IAdviseSink,
 156     &IID_IAdviseSinkEx,
 157     &IID_IPropertyNotifySink,
 158     &IID_IDispatch,
 159     &IID_IOleWindow,
 160     &IID_IOleInPlaceSite,
 161     &IID_IOleInPlaceSiteEx,
 162     &IID_IOleControlSite,
 163     &IID_IBindHost,
 164     &IID_IServiceProvider,
 165     NULL
 166 };
 167
 168 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 169 {
 170     IUnknown *unk1, *unk2;
 171
 172     if(iface1 == iface2)
 173         return TRUE;
 174
 175     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 176     IUnknown_Release(unk1);
 177     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 178     IUnknown_Release(unk2);
 179
 180     return unk1 == unk2;
 181 }
 182
 183 #define test_ifaces(i,ids) _test_ifaces(__LINE__,i,ids)
 184 static void _test_ifaces(unsigned line, IUnknown *iface, REFIID *iids)
 185 {
 186     const IID * const *piid;
 187     IUnknown *unk;
 188     HRESULT hres;
 189
 190      for(piid = iids; *piid; piid++) {
 191         hres = IUnknown_QueryInterface(iface, *piid, (void**)&unk);
 192         ok_(__FILE__,line) (hres == S_OK, "Could not get %s interface: %08x\n", wine_dbgstr_guid(*piid), hres);
 193         if(SUCCEEDED(hres))
 194             IUnknown_Release(unk);
 195     }
 196 }
 197
 198 static int strcmp_wa(LPCWSTR strw, const char *stra)
 199 {
 200     CHAR buf[512];
 201     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 202     return lstrcmpA(stra, buf);
 203 }
 204
 205 static BSTR a2bstr(const char *str)
 206 {
 207     BSTR ret;
 208     int len;
 209
 210     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 211     ret = SysAllocStringLen(NULL, len);
 212     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 213
 214     return ret;
 215 }
 216
 217 static IOleClientSite *client_site;
 218 static IDispatch *sink_disp;
 219 static READYSTATE plugin_readystate = READYSTATE_UNINITIALIZED;
 220 static BOOL have_container;
 221
 222 static void set_plugin_readystate(READYSTATE state)
 223 {
 224     IPropertyNotifySink *prop_notif;
 225     HRESULT hres;
 226
 227     plugin_readystate = state;
 228
 229     hres = IOleClientSite_QueryInterface(client_site, &IID_IPropertyNotifySink, (void**)&prop_notif);
 230     ok(hres == S_OK, "Could not get IPropertyNotifySink iface: %08x\n", hres);
 231
 232     hres = IPropertyNotifySink_OnChanged(prop_notif, DISPID_READYSTATE);
 233     ok(hres == S_OK, "OnChanged(DISPID_READYSTATE) failed: %08x\n", hres);
 234
 235     IPropertyNotifySink_Release(prop_notif);
 236 }
 237
 238 static void test_mon_displayname(IMoniker *mon, const char *exname, const char *broken_name)
 239 {
 240     LPOLESTR display_name;
 241     DWORD mksys;
 242     HRESULT hres;
 243
 244     hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
 245     ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 246     ok(!strcmp_wa(display_name, exname) || broken(broken_name && !strcmp_wa(display_name, broken_name)),
 247         "display_name = %s\n", wine_dbgstr_w(display_name));
 248     CoTaskMemFree(display_name);
 249
 250     hres = IMoniker_IsSystemMoniker(mon, &mksys);
 251     ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
 252     ok(mksys == MKSYS_URLMONIKER, "mksys = %d\n", mksys);
 253 }
 254
 255 static LRESULT WINAPI plugin_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 256 {
 257     switch(msg) {
 258     case WM_PAINT: {
 259         PAINTSTRUCT ps;
 260         HBRUSH brush;
 261         RECT rect;
 262         HDC dc;
 263
 264         GetClientRect(hwnd, &rect);
 265
 266         dc = BeginPaint(hwnd, &ps);
 267         brush = CreateSolidBrush(RGB(255,0,0));
 268         SelectObject(dc, brush);
 269         Rectangle(dc, rect.left, rect.top, rect.right, rect.bottom);
 270         DeleteObject(brush);
 271         EndPaint(hwnd, &ps);
 272         break;
 273     }
 274     }
 275
 276     return DefWindowProcW(hwnd, msg, wParam, lParam);
 277 }
 278
 279 static void create_plugin_window(HWND parent, const RECT *rect)
 280 {
 281     static const WCHAR plugin_testW[] =
 282         {'p','l','u','g','i','n',' ','t','e','s','t',0};
 283     static WNDCLASSEXW wndclass = {
 284         sizeof(WNDCLASSEXW),
 285         0,
 286         plugin_proc,
 287         0, 0, NULL, NULL, NULL, NULL, NULL,
 288         plugin_testW,
 289         NULL
 290     };
 291
 292     RegisterClassExW(&wndclass);
 293     plugin_hwnd = CreateWindowW(plugin_testW, plugin_testW,
 294             WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, rect->left, rect->top,
 295             rect->right-rect->left, rect->bottom-rect->top, parent, NULL, NULL, NULL);
 296 }
 297
 298 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface, REFIID riid, void **ppv)
 299 {
 300     ok(0, "unexpected QI call %s\n", wine_dbgstr_guid(riid));
 301     return E_NOINTERFACE;
 302 }
 303
 304 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
 305 {
 306     return 2;
 307 }
 308
 309 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
 310 {
 311     return 1;
 312 }
 313
 314 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
 315 {
 316     ok(0, "unexpected call\n");
 317     return E_NOTIMPL;
 318 }
 319
 320 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
 321         IConnectionPointContainer **ppCPC)
 322 {
 323     ok(0, "unexpected call\n");
 324     return E_NOTIMPL;
 325 }
 326
 327 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink, DWORD *pdwCookie)
 328 {
 329     DispActiveXTest *ax_test;
 330     IDispatchEx *dispex;
 331     HRESULT hres;
 332
 333     CHECK_EXPECT(Advise);
 334
 335     hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink_disp);
 336     ok(hres == S_OK, "Could not get IDispatch iface: %08x\n", hres);
 337
 338     hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatchEx, (void**)&dispex);
 339     ok(hres == E_NOINTERFACE, "QueryInterface(IID_IDispatchEx) returned: %08x\n", hres);
 340
 341     hres = IUnknown_QueryInterface(pUnkSink, &DIID_DispActiveXTest, (void**)&ax_test);
 342     ok(hres == S_OK, "Could not get DispActiveXTest iface: %08x\n", hres);
 343     DispActiveXTest_Release(ax_test);
 344
 345     *pdwCookie = 0xdeadbeef;
 346     return S_OK;
 347 }
 348
 349 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 350 {
 351     CHECK_EXPECT(Unadvise);
 352
 353     ok(dwCookie == 0xdeadbeef, "dwCookie = %x\n", dwCookie);
 354
 355     if(sink_disp) {
 356         IDispatch_Release(sink_disp);
 357         sink_disp = NULL;
 358     }
 359
 360     return S_OK;
 361 }
 362
 363 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface, IEnumConnections **ppEnum)
 364 {
 365     ok(0, "unexpected call\n");
 366     return E_NOTIMPL;
 367 }
 368
 369 static const IConnectionPointVtbl ConnectionPointVtbl = {
 370     ConnectionPoint_QueryInterface,
 371     ConnectionPoint_AddRef,
 372     ConnectionPoint_Release,
 373     ConnectionPoint_GetConnectionInterface,
 374     ConnectionPoint_GetConnectionPointContainer,
 375     ConnectionPoint_Advise,
 376     ConnectionPoint_Unadvise,
 377     ConnectionPoint_EnumConnections
 378 };
 379
 380 static IConnectionPoint ConnectionPoint = { &ConnectionPointVtbl };
 381
 382 static HRESULT ax_qi(REFIID,void**);
 383
 384 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 385 {
 386     return ax_qi(riid, ppv);
 387 }
 388
 389 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 390 {
 391     return ++activex_refcnt;
 392 }
 393
 394 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 395 {
 396     return --activex_refcnt;
 397 }
 398
 399 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 400 {
 401     ok(0, "unexpected call\n");
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
 406 {
 407     ok(0, "unexpected call\n");
 408     return E_NOTIMPL;
 409 }
 410
 411 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 412 {
 413     switch(dispID) {
 414     case DISPID_UNKNOWN:
 415         CHECK_EXPECT2(OnAmbientPropertyChange_UNKNOWN);
 416         break;
 417     default:
 418         ok(0, "unexpected call %d\n", dispID);
 419     }
 420
 421     return S_OK;
 422 }
 423
 424 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 425 {
 426     if(bFreeze)
 427         CHECK_EXPECT2(FreezeEvents_TRUE);
 428     else
 429         CHECK_EXPECT2(FreezeEvents_FALSE);
 430     return S_OK;
 431 }
 432
 433 static const IOleControlVtbl OleControlVtbl = {
 434     OleControl_QueryInterface,
 435     OleControl_AddRef,
 436     OleControl_Release,
 437     OleControl_GetControlInfo,
 438     OleControl_OnMnemonic,
 439     OleControl_OnAmbientPropertyChange,
 440     OleControl_FreezeEvents
 441 };
 442
 443 static IOleControl OleControl = { &OleControlVtbl };
 444
 445 static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
 446 {
 447     return ax_qi(riid, ppv);
 448 }
 449
 450 static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
 451 {
 452     return ++activex_refcnt;
 453 }
 454
 455 static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
 456 {
 457     return --activex_refcnt;
 458 }
 459
 460 static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
 461 {
 462     CHECK_EXPECT(QuickActivate);
 463
 464     ok(container != NULL, "container == NULL\n");
 465     ok(container->cbSize == sizeof(*container), "container->cbSize = %d\n", container->cbSize);
 466     ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
 467     ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
 468     ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
 469     ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
 470     ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
 471        "container->dwAmbientFlags = %x\n", container->dwAmbientFlags);
 472     if(have_container)
 473         ok(!container->colorFore, "container->colorFore = %d\n", container->colorFore); /* FIXME */
 474     todo_wine
 475     ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
 476     if(have_container)
 477         todo_wine ok(container->pFont != NULL, "container->pFont == NULL\n");
 478     else
 479         ok(!container->pFont, "container->pFont = %p\n", container->pFont);
 480     todo_wine
 481     ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
 482     ok(!container->dwAppearance, "container->dwAppearance = %x\n", container->dwAppearance);
 483     if(have_container)
 484         ok(!container->lcid, "container->lcid = %x\n", container->lcid);
 485     ok(!container->hpal, "container->hpal = %p\n", container->hpal);
 486     ok(!container->pBindHost, "container->pBindHost != NULL\n");
 487     ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
 488     ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
 489
 490     ok(control->cbSize == sizeof(*control), "control->cbSize = %d\n", control->cbSize);
 491     ok(!control->dwMiscStatus, "control->dwMiscStatus = %x\n", control->dwMiscStatus);
 492     ok(!control->dwViewStatus, "control->dwViewStatus = %x\n", control->dwViewStatus);
 493     ok(!control->dwEventCookie, "control->dwEventCookie = %x\n", control->dwEventCookie);
 494     ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %x\n", control->dwPropNotifyCookie);
 495     ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %x\n", control->dwPointerActivationPolicy);
 496
 497     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
 498        "container->pClientSite != container->pAdviseSink\n");
 499     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pPropertyNotifySink),
 500        "container->pClientSite != container->pPropertyNotifySink\n");
 501     test_ifaces((IUnknown*)container->pClientSite, pluginhost_iids);
 502
 503     IOleClientSite_AddRef(container->pClientSite);
 504     client_site = container->pClientSite;
 505
 506     control->dwMiscStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 507         |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 508     control->dwViewStatus = 0x18;
 509     control->dwPropNotifyCookie = 1;
 510
 511     return S_OK;
 512 }
 513
 514 static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 515 {
 516     ok(0, "unexpected call\n");
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 521 {
 522     ok(0, "unexpected call\n");
 523     return E_NOTIMPL;
 524 }
 525
 526 static const IQuickActivateVtbl QuickActivateVtbl = {
 527     QuickActivate_QueryInterface,
 528     QuickActivate_AddRef,
 529     QuickActivate_Release,
 530     QuickActivate_QuickActivate,
 531     QuickActivate_GetContentExtent,
 532     QuickActivate_SetContentExtent
 533 };
 534
 535 static IQuickActivate QuickActivate = { &QuickActivateVtbl };
 536
 537 static HRESULT WINAPI PersistPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
 538 {
 539     return ax_qi(riid, ppv);
 540 }
 541
 542 static ULONG WINAPI PersistPropertyBag_AddRef(IPersistPropertyBag *iface)
 543 {
 544     return ++activex_refcnt;
 545 }
 546
 547 static ULONG WINAPI PersistPropertyBag_Release(IPersistPropertyBag *iface)
 548 {
 549     return --activex_refcnt;
 550 }
 551
 552 static HRESULT WINAPI PersistPropertyBag_GetClassID(IPersistPropertyBag *face, CLSID *pClassID)
 553 {
 554     ok(0, "unexpected call\n");
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI PersistPropertyBag_InitNew(IPersistPropertyBag *face)
 559 {
 560     CHECK_EXPECT(IPersistPropertyBag_InitNew);
 561     return S_OK;
 562 }
 563
 564 static HRESULT WINAPI PersistPropertyBag_Load(IPersistPropertyBag *face, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
 565 {
 566     IBindHost *bind_host, *bind_host2;
 567     IServiceProvider *sp;
 568     IMoniker *mon;
 569     VARIANT v;
 570     HRESULT hres;
 571
 572     static const WCHAR param_nameW[] = {'p','a','r','a','m','_','n','a','m','e',0};
 573     static const WCHAR num_paramW[] = {'n','u','m','_','p','a','r','a','m',0};
 574     static const WCHAR no_paramW[] = {'n','o','_','p','a','r','a','m',0};
 575     static WCHAR test_swfW[] = {'t','e','s','t','.','s','w','f',0};
 576
 577     static const IID *propbag_ifaces[] = {
 578         &IID_IPropertyBag,
 579         &IID_IPropertyBag2,
 580         NULL
 581     };
 582
 583     CHECK_EXPECT(IPersistPropertyBag_Load);
 584
 585     ok(pPropBag != NULL, "pPropBag == NULL\n");
 586     ok(!pErrorLog, "pErrorLog != NULL\n");
 587
 588     test_ifaces((IUnknown*)pPropBag, propbag_ifaces);
 589
 590     V_VT(&v) = VT_BSTR;
 591     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 592     ok(hres == S_OK, "Read failed: %08x\n", hres);
 593     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 594     ok(!strcmp_wa(V_BSTR(&v), "param_value"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 595
 596     V_VT(&v) = VT_I4;
 597     V_I4(&v) = 0xdeadbeef;
 598     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 599     ok(hres == DISP_E_TYPEMISMATCH, "Read failed: %08x, expected DISP_E_TYPEMISMATCH\n", hres);
 600     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 601     ok(V_I4(&v) == 0xdeadbeef, "V_I4(v) = %x\n", V_I4(&v));
 602
 603     V_VT(&v) = VT_BSTR;
 604     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 605     ok(hres == S_OK, "Read failed: %08x\n", hres);
 606     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 607     ok(!strcmp_wa(V_BSTR(&v), "3"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 608     SysFreeString(V_BSTR(&v));
 609
 610     V_VT(&v) = VT_I4;
 611     V_I4(&v) = 0xdeadbeef;
 612     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 613     ok(hres == S_OK, "Read failed: %08x\n", hres);
 614     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 615     ok(V_I4(&v) == 3, "V_I4(v) = %x\n", V_I4(&v));
 616
 617     V_VT(&v) = VT_BSTR;
 618     V_BSTR(&v) = (BSTR)0xdeadbeef;
 619     hres = IPropertyBag_Read(pPropBag, no_paramW, &v, NULL);
 620     ok(hres == E_INVALIDARG, "Read failed: %08x\n", hres);
 621     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 622     ok(V_BSTR(&v) == (BSTR)0xdeadbeef, "V_BSTR(v) = %p\n", V_BSTR(&v));
 623
 624     set_plugin_readystate(READYSTATE_INTERACTIVE);
 625
 626     hres = IOleClientSite_QueryInterface(client_site, &IID_IBindHost, (void**)&bind_host);
 627     ok(hres == S_OK, "Could not get IBindHost iface: %08x\n", hres);
 628
 629     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&sp);
 630     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
 631
 632     hres = IServiceProvider_QueryService(sp, &SID_SBindHost, &IID_IBindHost, (void**)&bind_host2);
 633     ok(hres == S_OK, "QueryService(SID_SBindHost) failed: %08x\n", hres);
 634     IServiceProvider_Release(sp);
 635
 636     ok(iface_cmp((IUnknown*)bind_host, (IUnknown*)bind_host2), "bind_host != bind_host2\n");
 637     IBindHost_Release(bind_host2);
 638
 639     mon = NULL;
 640     hres = IBindHost_CreateMoniker(bind_host, test_swfW, NULL, &mon, 0);
 641     ok(hres == S_OK, "CreateMoniker failed: %08x\n", hres);
 642     ok(mon != NULL, "mon == NULL\n");
 643     test_mon_displayname(mon, "about:test.swf", "about:blanktest.swf");
 644     IMoniker_Release(mon);
 645
 646     IBindHost_Release(bind_host);
 647
 648     mon = NULL;
 649     hres = IOleClientSite_GetMoniker(client_site, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &mon);
 650     ok(hres == S_OK, "GetMoniker failed: %08x\n", hres);
 651     ok(mon != NULL, "mon == NULL\n");
 652     test_mon_displayname(mon, "about:blank", NULL);
 653     IMoniker_Release(mon);
 654
 655     set_plugin_readystate(READYSTATE_COMPLETE);
 656
 657     return S_OK;
 658 }
 659
 660 static HRESULT WINAPI PersistPropertyBag_Save(IPersistPropertyBag *face, IPropertyBag *pPropBag, BOOL fClearDisrty, BOOL fSaveAllProperties)
 661 {
 662     ok(0, "unexpected call\n");
 663     return E_NOTIMPL;
 664 }
 665
 666 static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
 667     PersistPropertyBag_QueryInterface,
 668     PersistPropertyBag_AddRef,
 669     PersistPropertyBag_Release,
 670     PersistPropertyBag_GetClassID,
 671     PersistPropertyBag_InitNew,
 672     PersistPropertyBag_Load,
 673     PersistPropertyBag_Save
 674
 675 };
 676
 677 static IPersistPropertyBag PersistPropertyBag = { &PersistPropertyBagVtbl };
 678
 679 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 680 {
 681     return ax_qi(riid, ppv);
 682 }
 683
 684 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 685 {
 686     return ++activex_refcnt;
 687 }
 688
 689 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 690 {
 691     return --activex_refcnt;
 692 }
 693
 694 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 695 {
 696     ok(0, "unexpected call\n");
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 701         ITypeInfo **ppTInfo)
 702 {
 703     CHECK_EXPECT(GetTypeInfo);
 704
 705     ITypeInfo_AddRef(actxtest_typeinfo);
 706     *ppTInfo = actxtest_typeinfo;
 707     return S_OK;
 708 }
 709
 710 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 711         UINT cNames, LCID lcid, DISPID *rgDispId)
 712 {
 713     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", wine_dbgstr_guid(riid));
 714     ok(cNames == 1, "cNames = %d\n", cNames);
 715     ok(rgszNames != NULL, "rgszNames == NULL\n");
 716     ok(rgDispId != NULL, "rgDispId == NULL\n");
 717
 718     if(!strcmp_wa(rgszNames[0], "scriptprop")) {
 719         CHECK_EXPECT(GetIDsOfNames_scriptprop);
 720         *rgDispId = DISPID_SCRIPTPROP;
 721     }else if(!strcmp_wa(rgszNames[0], "scriptCall")) {
 722         *rgDispId = DISPID_SCRIPTCALL;
 723     }else {
 724         ok(0, "rgszNames[0] = %s\n", wine_dbgstr_w(rgszNames[0]));
 725     }
 726
 727     return S_OK;
 728 }
 729
 730 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 731         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 732         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 733 {
 734     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", wine_dbgstr_guid(riid));
 735     ok(pDispParams != NULL, "pDispParams == NULL\n");
 736     ok(!pDispParams->cNamedArgs, "pDispParams->cNamedArgs = %d\n", pDispParams->cNamedArgs);
 737     ok(!pDispParams->rgdispidNamedArgs, "pDispParams->rgdispidNamedArgs != NULL\n");
 738
 739     switch(dispIdMember) {
 740     case DISPID_READYSTATE:
 741         CHECK_EXPECT2(Invoke_READYSTATE);
 742         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 743         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 744         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 745         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 746         ok(puArgErr != NULL, "puArgErr == NULL\n");
 747         ok(pVarResult != NULL, "pVarResult == NULL\n");
 748
 749         V_VT(pVarResult) = VT_I4;
 750         V_I4(pVarResult) = plugin_readystate;
 751         return S_OK;
 752      case DISPID_ENABLED:
 753         CHECK_EXPECT2(Invoke_ENABLED);
 754         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 755         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 756         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 757         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 758         ok(puArgErr != NULL, "puArgErr == NULL\n");
 759         ok(pVarResult != NULL, "pVarResult == NULL\n");
 760         return DISP_E_MEMBERNOTFOUND;
 761     case DISPID_VALID:
 762         CHECK_EXPECT(Invoke_VALID);
 763         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 764         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 765         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 766         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 767         ok(puArgErr != NULL, "puArgErr == NULL\n");
 768         ok(pVarResult != NULL, "pVarResult == NULL\n");
 769         return DISP_E_MEMBERNOTFOUND;
 770     case DISPID_SECURITYCTX:
 771         CHECK_EXPECT(Invoke_SECURITYCTX);
 772         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 773         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 774         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 775         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 776         ok(puArgErr != NULL, "puArgErr == NULL\n");
 777         ok(pVarResult != NULL, "pVarResult == NULL\n");
 778         return DISP_E_MEMBERNOTFOUND;
 779     case DISPID_SCRIPTPROP:
 780         CHECK_EXPECT(Invoke_SCRIPTPROP);
 781         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 782         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 783         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 784         ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
 785         ok(!puArgErr, "puArgErr != NULL\n");
 786         ok(pVarResult != NULL, "pVarResult == NULL\n");
 787
 788         V_VT(pVarResult) = VT_I4;
 789         V_I4(pVarResult) = 4;
 790         return S_OK;
 791     case DISPID_SCRIPTCALL:
 792         CHECK_EXPECT(Invoke_SCRIPTCALL);
 793         ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 794         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 795         ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
 796         ok(!puArgErr, "puArgErr != NULL\n");
 797         ok(!pVarResult, "pVarResult != NULL\n");
 798         /*
 799         V_VT(pVarResult) = VT_I4;
 800         V_I4(pVarResult) = 4;
 801         */
 802         return S_OK;
 803     default:
 804         ok(0, "unexpected call %d\n", dispIdMember);
 805     }
 806
 807     return E_NOTIMPL;
 808 }
 809
 810 static const IDispatchVtbl DispatchVtbl = {
 811     Dispatch_QueryInterface,
 812     Dispatch_AddRef,
 813     Dispatch_Release,
 814     Dispatch_GetTypeInfoCount,
 815     Dispatch_GetTypeInfo,
 816     Dispatch_GetIDsOfNames,
 817     Dispatch_Invoke
 818 };
 819
 820 static IDispatch Dispatch = { &DispatchVtbl };
 821
 822 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo *iface, REFIID riid, void **ppv)
 823 {
 824     return ax_qi(riid, ppv);
 825 }
 826
 827 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo *iface)
 828 {
 829     return ++activex_refcnt;
 830 }
 831
 832 static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo *iface)
 833 {
 834     return --activex_refcnt;
 835 }
 836
 837 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo *iface, ITypeInfo **ppTI)
 838 {
 839     CHECK_EXPECT(GetClassInfo);
 840
 841     ITypeInfo_AddRef(class_typeinfo);
 842     *ppTI = class_typeinfo;
 843     return S_OK;
 844 }
 845
 846 static const IProvideClassInfoVtbl ProvideClassInfoVtbl = {
 847     ProvideClassInfo_QueryInterface,
 848     ProvideClassInfo_AddRef,
 849     ProvideClassInfo_Release,
 850     ProvideClassInfo_GetClassInfo
 851 };
 852
 853 static IProvideClassInfo ProvideClassInfo = { &ProvideClassInfoVtbl };
 854
 855 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface, REFIID riid, void **ppv)
 856 {
 857     return ax_qi(riid, ppv);
 858 }
 859
 860 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 861 {
 862     return ++activex_refcnt;
 863 }
 864
 865 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 866 {
 867     return --activex_refcnt;
 868 }
 869
 870 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 871         IEnumConnectionPoints **ppEnum)
 872 {
 873     ok(0, "unexpected call\n");
 874     return E_NOTIMPL;
 875 }
 876
 877 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 878         REFIID riid, IConnectionPoint **ppCP)
 879 {
 880     if(IsEqualGUID(riid, &IID_IPropertyNotifySink)) {
 881         /* TODO */
 882         trace("FindConnectionPoint(IID_IPropertyNotifySink)\n");
 883         return CONNECT_E_NOCONNECTION;
 884     }
 885
 886     CHECK_EXPECT(FindConnectionPoint);
 887     ok(IsEqualGUID(riid, &DIID_DispActiveXTest), "riid = %s\n", wine_dbgstr_guid(riid));
 888
 889     IConnectionPoint_AddRef(&ConnectionPoint);
 890     *ppCP = &ConnectionPoint;
 891     return S_OK;
 892 }
 893
 894 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
 895     ConnectionPointContainer_QueryInterface,
 896     ConnectionPointContainer_AddRef,
 897     ConnectionPointContainer_Release,
 898     ConnectionPointContainer_EnumConnectionPoints,
 899     ConnectionPointContainer_FindConnectionPoint
 900 };
 901
 902 static IConnectionPointContainer ConnectionPointContainer = { &ConnectionPointContainerVtbl };
 903
 904 static HRESULT WINAPI ViewObjectEx_QueryInterface(IViewObjectEx *iface, REFIID riid, void **ppv)
 905 {
 906     return ax_qi(riid, ppv);
 907 }
 908
 909 static ULONG WINAPI ViewObjectEx_AddRef(IViewObjectEx *iface)
 910 {
 911     return ++activex_refcnt;
 912 }
 913
 914 static ULONG WINAPI ViewObjectEx_Release(IViewObjectEx *iface)
 915 {
 916     return --activex_refcnt;
 917 }
 918
 919 static HRESULT WINAPI ViewObjectEx_Draw(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 920         HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBoungs, BOOL (WINAPI*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
 921 {
 922     ok(0, "unexpected call\n");
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT WINAPI ViewObjectEx_GetColorSet(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 927         HDC hicTargetDev, LOGPALETTE **ppColorSet)
 928 {
 929     ok(0, "unexpected call\n");
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI ViewObjectEx_Freeze(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
 934 {
 935     ok(0, "unexpected call\n");
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI ViewObjectEx_Unfreeze(IViewObjectEx *iface, DWORD dwFreeze)
 940 {
 941     ok(0, "unexpected call\n");
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI ViewObjectEx_SetAdvise(IViewObjectEx *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
 946 {
 947     CHECK_EXPECT(SetAdvise);
 948
 949     ok(aspects == DVASPECT_CONTENT, "aspects = %x\n", aspects);
 950     ok(!advf, "advf = %x\n", advf);
 951     ok(pAdvSink != NULL, "pAdvSink = NULL\n");
 952
 953     return S_OK;
 954 }
 955
 956 static HRESULT WINAPI ViewObjectEx_GetAdvise(IViewObjectEx *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
 957 {
 958     ok(0, "unexpected call\n");
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI ViewObjectEx_GetExtent(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
 963 {
 964     ok(0, "unexpected call\n");
 965     return E_NOTIMPL;
 966 }
 967
 968 static HRESULT WINAPI ViewObjectEx_GetRect(IViewObjectEx *iface, DWORD dwAspect, LPRECTL pRect)
 969 {
 970     ok(0, "unexpected call\n");
 971     return E_NOTIMPL;
 972 }
 973
 974 static HRESULT WINAPI ViewObjectEx_GetViewStatus(IViewObjectEx *iface, DWORD *pdwStatus)
 975 {
 976     CHECK_EXPECT(GetViewStatus);
 977
 978     *pdwStatus = VIEWSTATUS_OPAQUE|VIEWSTATUS_SOLIDBKGND;
 979     return S_OK;
 980 }
 981
 982 static HRESULT WINAPI ViewObjectEx_QueryHitPoint(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc,
 983         LONG lCloseHint, DWORD *pHitResult)
 984 {
 985     trace("QueryHitPoint call ignored\n");
 986     return E_NOTIMPL;
 987 }
 988
 989 static HRESULT WINAPI ViewObjectEx_QueryHitRect(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc,
 990         LONG lCloseHint, DWORD *pHitResult)
 991 {
 992     ok(0, "unexpected call\n");
 993     return E_NOTIMPL;
 994 }
 995
 996 static HRESULT WINAPI ViewObjectEx_GetNaturalExtent(IViewObjectEx *iface, DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd,
 997         HDC hicTargetDev, DVEXTENTINFO *pExtentIngo, LPSIZEL pSizel)
 998 {
 999     ok(0, "unexpected call\n");
1000     return E_NOTIMPL;
1001 }
1002
1003 static const IViewObjectExVtbl ViewObjectExVtbl = {
1004     ViewObjectEx_QueryInterface,
1005     ViewObjectEx_AddRef,
1006     ViewObjectEx_Release,
1007     ViewObjectEx_Draw,
1008     ViewObjectEx_GetColorSet,
1009     ViewObjectEx_Freeze,
1010     ViewObjectEx_Unfreeze,
1011     ViewObjectEx_SetAdvise,
1012     ViewObjectEx_GetAdvise,
1013     ViewObjectEx_GetExtent,
1014     ViewObjectEx_GetRect,
1015     ViewObjectEx_GetViewStatus,
1016     ViewObjectEx_QueryHitPoint,
1017     ViewObjectEx_QueryHitRect,
1018     ViewObjectEx_GetNaturalExtent
1019 };
1020
1021 static IViewObjectEx ViewObjectEx = { &ViewObjectExVtbl };
1022
1023 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
1024 {
1025     return ax_qi(riid, ppv);
1026 }
1027
1028 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
1029 {
1030     return ++activex_refcnt;
1031 }
1032
1033 static ULONG WINAPI OleObject_Release(IOleObject *iface)
1034 {
1035     return --activex_refcnt;
1036 }
1037
1038 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
1039 {
1040     if(!pClientSite) {
1041         CHECK_EXPECT(SetClientSite_NULL);
1042         return S_OK;
1043     }
1044
1045     CHECK_EXPECT(SetClientSite);
1046
1047     IOleClientSite_AddRef(pClientSite);
1048     client_site = pClientSite;
1049     return S_OK;
1050 }
1051
1052 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
1053 {
1054     ok(0, "unexpected call\n");
1055     return E_NOTIMPL;
1056 }
1057
1058 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
1059 {
1060     ok(0, "unexpected call\n");
1061     return E_NOTIMPL;
1062 }
1063
1064 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
1065 {
1066     CHECK_EXPECT(Close);
1067
1068     ok(dwSaveOption == OLECLOSE_NOSAVE, "dwSaveOption = %d\n", dwSaveOption);
1069     return S_OK;
1070 }
1071
1072 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
1073 {
1074     ok(0, "unexpected call\n");
1075     return E_NOTIMPL;
1076 }
1077
1078 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
1079 {
1080     ok(0, "unexpected call\n");
1081     return E_NOTIMPL;
1082 }
1083
1084 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
1085         DWORD dwReserved)
1086 {
1087     ok(0, "unexpected call\n");
1088     return E_NOTIMPL;
1089 }
1090
1091 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
1092 {
1093     ok(0, "unexpected call\n");
1094     return E_NOTIMPL;
1095 }
1096
1097 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
1098         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
1099 {
1100     OLEINPLACEFRAMEINFO frame_info = {0xdeadbeef};
1101     IOleInPlaceUIWindow *ip_uiwindow;
1102     IOleInPlaceFrame *ip_frame;
1103     IOleInPlaceSiteEx *ip_site;
1104     RECT pos_rect, clip_rect;
1105     BOOL no_redraw;
1106     HWND hwnd;
1107     HRESULT hres;
1108
1109     CHECK_EXPECT(DoVerb);
1110
1111     ok(iVerb == OLEIVERB_INPLACEACTIVATE, "iVerb = %d\n", iVerb);
1112     ok(!lpmsg, "lpmsg != NULL\n");
1113     ok(pActiveSite != NULL, "pActiveSite == NULL\n");
1114     ok(!lindex, "lindex = %d\n", lindex);
1115     ok(hwndParent != NULL, "hwndParent == NULL\n");
1116     ok(lprcPosRect != NULL, "lprcPosRect == NULL\n");
1117
1118     hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleInPlaceSiteEx, (void**)&ip_site);
1119     ok(hres == S_OK, "Could not get IOleInPlaceSiteEx iface: %08x\n", hres);
1120
1121     hres = IOleInPlaceSiteEx_CanInPlaceActivate(ip_site);
1122     ok(hres == S_OK, "CanInPlaceActivate failed: %08x\n", hres);
1123
1124     SET_EXPECT(InPlaceObject_GetWindow);
1125     no_redraw = 0xdeadbeef;
1126     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
1127     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
1128     ok(!no_redraw, "no_redraw = %x\n", no_redraw);
1129     CHECK_CALLED(InPlaceObject_GetWindow);
1130
1131     no_redraw = 0xdeadbeef;
1132     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
1133     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
1134     ok(no_redraw == 0xdeadbeef, "no_redraw = %x\n", no_redraw);
1135
1136     hwnd = NULL;
1137     hres = IOleInPlaceSiteEx_GetWindow(ip_site, &hwnd);
1138     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1139     ok(hwnd != NULL, "hwnd == NULL\n");
1140     ok(hwnd == hwndParent, "hwnd != hwndParent\n");
1141
1142     create_plugin_window(hwnd, lprcPosRect);
1143
1144     ip_frame = NULL;
1145     ip_uiwindow = NULL;
1146     frame_info.cb = sizeof(OLEINPLACEFRAMEINFO);
1147     hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
1148     ok(hres == S_OK, "GetWindowContext failed: %08x\n", hres);
1149     ok(ip_frame != NULL, "ip_frame == NULL\n");
1150     ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
1151     ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
1152     ok(EqualRect(&pos_rect, lprcPosRect), "pos_rect != lpecPosRect\n");
1153     ok(EqualRect(&clip_rect, lprcPosRect), "clip_rect != lpecPosRect\n");
1154     ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
1155     ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
1156     ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
1157     ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
1158     ok(!frame_info.haccel, "frame_info.haccel != 0\n");
1159     ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
1160
1161     IOleInPlaceFrame_Release(ip_frame);
1162     IOleInPlaceUIWindow_Release(ip_uiwindow);
1163
1164
1165     IOleInPlaceSiteEx_Release(ip_site);
1166
1167     hres = IOleClientSite_ShowObject(client_site);
1168     ok(hres == S_OK, "ShowObject failed: %08x\n", hres);
1169
1170     SET_EXPECT(InPlaceObject_GetWindow);
1171     SET_EXPECT(SetObjectRects);
1172
1173     return S_OK;
1174 }
1175
1176 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
1177 {
1178     ok(0, "unexpected call\n");
1179     return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
1183 {
1184     ok(0, "unexpected call\n");
1185     return E_NOTIMPL;
1186 }
1187
1188 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
1189 {
1190     ok(0, "unexpected call\n");
1191     return E_NOTIMPL;
1192 }
1193
1194 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
1195 {
1196     ok(0, "unexpected call\n");
1197     return E_NOTIMPL;
1198 }
1199
1200 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
1201 {
1202     ok(0, "unexpected call\n");
1203     return E_NOTIMPL;
1204 }
1205
1206 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
1207 {
1208     CHECK_EXPECT(SetExtent);
1209     return E_NOTIMPL;
1210 }
1211
1212 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
1213 {
1214     CHECK_EXPECT(GetExtent);
1215     return E_NOTIMPL;
1216 }
1217
1218 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
1219 {
1220     ok(0, "unexpected call\n");
1221     return E_NOTIMPL;
1222 }
1223
1224 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
1225 {
1226     ok(0, "unexpected call\n");
1227     return E_NOTIMPL;
1228 }
1229
1230 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
1231 {
1232     ok(0, "unexpected call\n");
1233     return E_NOTIMPL;
1234 }
1235
1236 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
1237 {
1238     CHECK_EXPECT(GetMiscStatus);
1239     ok(dwAspect == DVASPECT_CONTENT, "dwAspect = %d\n", dwAspect);
1240     ok(pdwStatus != NULL, "pdwStatus == NULL\n");
1241     *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE
1242         |OLEMISC_INSIDEOUT|OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
1243     return S_OK;
1244 }
1245
1246 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
1247 {
1248     ok(0, "unexpected call\n");
1249     return E_NOTIMPL;
1250 }
1251
1252 static const IOleObjectVtbl OleObjectVtbl = {
1253     OleObject_QueryInterface,
1254     OleObject_AddRef,
1255     OleObject_Release,
1256     OleObject_SetClientSite,
1257     OleObject_GetClientSite,
1258     OleObject_SetHostNames,
1259     OleObject_Close,
1260     OleObject_SetMoniker,
1261     OleObject_GetMoniker,
1262     OleObject_InitFromData,
1263     OleObject_GetClipboardData,
1264     OleObject_DoVerb,
1265     OleObject_EnumVerbs,
1266     OleObject_Update,
1267     OleObject_IsUpToDate,
1268     OleObject_GetUserClassID,
1269     OleObject_GetUserType,
1270     OleObject_SetExtent,
1271     OleObject_GetExtent,
1272     OleObject_Advise,
1273     OleObject_Unadvise,
1274     OleObject_EnumAdvise,
1275     OleObject_GetMiscStatus,
1276     OleObject_SetColorScheme
1277 };
1278
1279 static IOleObject OleObject = { &OleObjectVtbl };
1280
1281 static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
1282         REFIID riid, void **ppv)
1283 {
1284     return ax_qi(riid, ppv);
1285 }
1286
1287 static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
1288 {
1289     return ++activex_refcnt;
1290 }
1291
1292 static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
1293 {
1294     return --activex_refcnt;
1295 }
1296
1297 static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
1298         HWND *phwnd)
1299 {
1300     CHECK_EXPECT2(InPlaceObject_GetWindow);
1301
1302     ok(phwnd != NULL, "phwnd == NULL\n");
1303
1304     *phwnd = plugin_hwnd;
1305     return *phwnd ? S_OK : E_UNEXPECTED;
1306 }
1307
1308 static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
1309         BOOL fEnterMode)
1310 {
1311     ok(0, "unexpected call\n");
1312     return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
1316 {
1317     IOleInPlaceSite *ip_site;
1318     HRESULT hres;
1319
1320     CHECK_EXPECT(InPlaceDeactivate);
1321
1322     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1323     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1324
1325     hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
1326     ok(hres == S_OK, "OnInPlaceDeactivate failed: %08x\n", hres);
1327
1328     IOleInPlaceSite_Release(ip_site);
1329     return S_OK;
1330 }
1331
1332 static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
1333 {
1334     CHECK_EXPECT2(UIDeactivate);
1335     return S_OK;
1336 }
1337
1338 static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
1339         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
1340 {
1341     CHECK_EXPECT2(SetObjectRects);
1342     return S_OK;
1343 }
1344
1345 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
1346 {
1347     ok(0, "unexpected call\n");
1348     return E_NOTIMPL;
1349 }
1350
1351 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
1352         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
1353 {
1354     ok(0, "unexpected call\n");
1355     return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
1359         IDropTarget **ppDropTarget)
1360 {
1361     ok(0, "unexpected call\n");
1362     return E_NOTIMPL;
1363 }
1364
1365 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
1366     OleInPlaceObject_QueryInterface,
1367     OleInPlaceObject_AddRef,
1368     OleInPlaceObject_Release,
1369     OleInPlaceObject_GetWindow,
1370     OleInPlaceObject_ContextSensitiveHelp,
1371     OleInPlaceObject_InPlaceDeactivate,
1372     OleInPlaceObject_UIDeactivate,
1373     OleInPlaceObject_SetObjectRects,
1374     OleInPlaceObjectWindowless_ReactivateAndUndo,
1375     OleInPlaceObjectWindowless_OnWindowMessage,
1376     OleInPlaceObjectWindowless_GetDropTarget
1377 };
1378
1379 static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
1380
1381 static void *wrapped_iface_vtbl[100];
1382 static IUnknown wrapped_iface = { (IUnknownVtbl*)wrapped_iface_vtbl };
1383
1384 static HRESULT WINAPI wrapped_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1385 {
1386     ok(0, "unexpected wrapped_QueryInterface call\n");
1387     *ppv = NULL;
1388     return E_NOINTERFACE;
1389 }
1390
1391 static ULONG WINAPI wrapped_AddRef(IUnknown *iface)
1392 {
1393     CHECK_EXPECT(wrapped_AddRef);
1394     return 2;
1395 }
1396
1397 static ULONG WINAPI wrapped_Release(IUnknown *iface)
1398 {
1399     CHECK_EXPECT(wrapped_Release);
1400     return 1;
1401 }
1402
1403 static HRESULT WINAPI wrapped_func_nocall(IUnknown *iface, int i, double d)
1404 {
1405     ok(0, "unexpected call\n");
1406     return E_FAIL;
1407 }
1408
1409 static HRESULT WINAPI wrapped_func(IUnknown *iface, int i, double d)
1410 {
1411     CHECK_EXPECT(wrapped_func);
1412     ok(iface == &wrapped_iface, "iface != wrapped_iface\n");
1413     ok(i == 10, "i = %d\n", i);
1414     ok(d == 32.0, "d = %lf\n", d);
1415     return S_OK;
1416 }
1417
1418 static void init_wrapped_iface(void)
1419 {
1420     unsigned i;
1421
1422     wrapped_iface_vtbl[0] = wrapped_QueryInterface;
1423     wrapped_iface_vtbl[1] = wrapped_AddRef;
1424     wrapped_iface_vtbl[2] = wrapped_Release;
1425
1426     for(i=3; i<100; i++)
1427         wrapped_iface_vtbl[i] = wrapped_func_nocall;
1428
1429     wrapped_iface_vtbl[63] = wrapped_func;
1430 }
1431
1432 static HRESULT ax_qi(REFIID riid, void **ppv)
1433 {
1434     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
1435         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleControl;
1436     }else if(IsEqualGUID(riid, &IID_IQuickActivate)) {
1437         *ppv = no_quickact ? NULL : &QuickActivate;
1438     }else if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
1439         *ppv = no_quickact ? NULL : &PersistPropertyBag;
1440     }else if(IsEqualGUID(riid, &IID_IDispatch)) {
1441         *ppv = &Dispatch;
1442     }else if(IsEqualGUID(riid, &IID_IProvideClassInfo)) {
1443         *ppv = &ProvideClassInfo;
1444     }else if(IsEqualGUID(riid, &IID_IConnectionPointContainer)) {
1445         *ppv = plugin_behavior != TEST_DISPONLY ? &ConnectionPointContainer : NULL;
1446     }else if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2)
1447             || IsEqualGUID(riid, &IID_IViewObjectEx)) {
1448         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &ViewObjectEx;
1449     }else if(IsEqualGUID(riid, &IID_IOleObject)) {
1450         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleObject;
1451     }else if(IsEqualGUID(riid, &IID_ITestActiveX)) {
1452         CHECK_EXPECT(QI_ITestActiveX);
1453         *ppv = &wrapped_iface;
1454         return S_OK;
1455     }else  if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
1456        || IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
1457         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleInPlaceObjectWindowless;
1458     }else {
1459         trace("QI %s\n", wine_dbgstr_guid(riid));
1460         *ppv = NULL;
1461     }
1462
1463     if(!*ppv)
1464         return E_NOINTERFACE;
1465
1466     IUnknown_AddRef((IUnknown*)*ppv);
1467     return S_OK;
1468 }
1469
1470 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1471 {
1472     *ppv = NULL;
1473
1474     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1475         *ppv = iface;
1476         return S_OK;
1477     }
1478
1479     if(IsEqualGUID(&IID_IMarshal, riid))
1480         return E_NOINTERFACE;
1481     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1482         return E_NOINTERFACE;
1483     if(IsEqualGUID(&IID_IClassFactoryEx, riid))
1484         return E_NOINTERFACE; /* TODO */
1485
1486     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
1487     return E_NOTIMPL;
1488 }
1489
1490 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1491 {
1492     return 2;
1493 }
1494
1495 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1496 {
1497     return 1;
1498 }
1499
1500 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1501 {
1502     CHECK_EXPECT(CreateInstance);
1503
1504     ok(!outer, "outer = %p\n", outer);
1505     ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", wine_dbgstr_guid(riid));
1506
1507     activex_refcnt++;
1508     *ppv = &OleControl;
1509     return S_OK;
1510 }
1511
1512 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1513 {
1514     ok(0, "unexpected call\n");
1515     return S_OK;
1516 }
1517
1518 static const IClassFactoryVtbl ClassFactoryVtbl = {
1519     ClassFactory_QueryInterface,
1520     ClassFactory_AddRef,
1521     ClassFactory_Release,
1522     ClassFactory_CreateInstance,
1523     ClassFactory_LockServer
1524 };
1525
1526 static IClassFactory activex_cf = { &ClassFactoryVtbl };
1527
1528 static void test_elem_dispex(IDispatchEx *dispex)
1529 {
1530     DISPPARAMS dp;
1531     EXCEPINFO ei;
1532     VARIANT v;
1533     DISPID id;
1534     BSTR str;
1535     HRESULT hres;
1536
1537     str = a2bstr("scriptprop");
1538     SET_EXPECT(GetIDsOfNames_scriptprop);
1539     hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
1540     CHECK_CALLED(GetIDsOfNames_scriptprop);
1541     SysFreeString(str);
1542     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1543     todo_wine
1544     ok(id == DISPID_SCRIPTPROP, "id = %d\n", id);
1545
1546     SET_EXPECT(Invoke_SECURITYCTX);
1547     SET_EXPECT(Invoke_SCRIPTPROP);
1548     memset(&dp, 0, sizeof(dp));
1549     memset(&ei, 0, sizeof(ei));
1550     V_VT(&v) = VT_EMPTY;
1551     hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
1552     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1553     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
1554     ok(V_I4(&v) == 4, "V_I4(v) = %d\n", V_I4(&v));
1555     CHECK_CALLED(Invoke_SECURITYCTX);
1556     CHECK_CALLED(Invoke_SCRIPTPROP);
1557 }
1558
1559 static void test_iface_wrapping(IHTMLObjectElement *elem)
1560 {
1561     IHTMLObjectElement *elem2;
1562     IUnknown *unk, *unk2;
1563     ULONG ref;
1564     void **vtbl;
1565     HRESULT hres;
1566
1567     SET_EXPECT(QI_ITestActiveX);
1568     SET_EXPECT(wrapped_AddRef);
1569     SET_EXPECT(wrapped_Release);
1570     unk = (void*)0xdeadbeef;
1571     hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk);
1572     ok(hres == S_OK, "QueryInterface(IID_ITestActiveX failed: %08x\n", hres);
1573     CHECK_CALLED(QI_ITestActiveX);
1574     CHECK_CALLED(wrapped_AddRef);
1575     CHECK_CALLED(wrapped_Release);
1576
1577     /* See dlls/mshtml/ifacewrap.c */
1578     ok(unk != &wrapped_iface, "Unexpected unk %p, expected %p (%p, %p)\n", unk, &ViewObjectEx, unk->lpVtbl, &ViewObjectExVtbl);
1579     ok(unk->lpVtbl != wrapped_iface.lpVtbl, "unk->lpVtbl == wrapped_iface->lpVtbl\n");
1580     ok(unk->lpVtbl->QueryInterface != wrapped_QueryInterface, "QueryInterface not wrapped\n");
1581     ok(unk->lpVtbl->AddRef != wrapped_AddRef, "AddRef not wrapped\n");
1582     ok(unk->lpVtbl->Release != wrapped_Release, "Release not wrapped\n");
1583
1584     vtbl = (void**)unk->lpVtbl;
1585     ok(vtbl[4] != wrapped_func_nocall, "func not wrapped\n");
1586     ok(vtbl[63] != wrapped_func, "func not wrapped\n");
1587
1588     SET_EXPECT(wrapped_func);
1589     hres = ((HRESULT (WINAPI*)(IUnknown*,int,double))vtbl[63])(unk, 10, 32.0);
1590     ok(hres == S_OK, "wrapped_func returned %08x\n", hres);
1591     CHECK_CALLED(wrapped_func);
1592
1593     hres = IUnknown_QueryInterface(unk, &IID_IHTMLObjectElement, (void**)&elem2);
1594     ok(hres == S_OK, "Could not get IHTMLObjectElement from wrapped iface: %08x\n", hres);
1595     ok(iface_cmp((IUnknown*)elem2, (IUnknown*)elem), "elem2 != elem\n");
1596     IHTMLObjectElement_Release(elem2);
1597
1598     SET_EXPECT(wrapped_Release);
1599     ref = IUnknown_Release(unk);
1600     ok(!ref, "ref=%d\n", ref);
1601     CHECK_CALLED(wrapped_Release);
1602
1603     SET_EXPECT(QI_ITestActiveX);
1604     SET_EXPECT(wrapped_AddRef);
1605     SET_EXPECT(wrapped_Release);
1606     unk = (void*)0xdeadbeef;
1607     hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk2);
1608     ok(hres == S_OK, "QueryInterface(IID_ITestActiveX failed: %08x\n", hres);
1609     CHECK_CALLED(QI_ITestActiveX);
1610     CHECK_CALLED(wrapped_AddRef);
1611     CHECK_CALLED(wrapped_Release);
1612
1613     ok(unk != unk2, "unk == unk2\n");
1614
1615     SET_EXPECT(wrapped_Release);
1616     ref = IUnknown_Release(unk2);
1617     ok(!ref, "ref=%d\n", ref);
1618     CHECK_CALLED(wrapped_Release);
1619 }
1620
1621 static void test_object_elem(IHTMLDocument2 *doc)
1622 {
1623     IHTMLObjectElement *objelem;
1624     IHTMLDocument3 *doc3;
1625     IDispatchEx *dispex;
1626     IHTMLElement *elem;
1627     IDispatch *disp;
1628     VARIANT v;
1629     BSTR str;
1630     HRESULT hres;
1631
1632     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1633     ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
1634
1635     str = a2bstr("objid");
1636     elem = (void*)0xdeadbeef;
1637     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
1638     IHTMLDocument3_Release(doc3);
1639     SysFreeString(str);
1640     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1641     ok(elem != NULL, "elem == NULL\n");
1642
1643     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
1644     IHTMLElement_Release(elem);
1645     ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08x\n", hres);
1646
1647     SET_EXPECT(Invoke_SECURITYCTX);
1648     hres = IHTMLObjectElement_get_object(objelem, &disp);
1649     ok(hres == S_OK, "get_object failed: %08x\n", hres);
1650     ok(disp == &Dispatch, "disp != Dispatch\n");
1651     CHECK_CALLED(Invoke_SECURITYCTX);
1652
1653     hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
1654     ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
1655     test_elem_dispex(dispex);
1656     IDispatchEx_Release(dispex);
1657
1658     test_iface_wrapping(objelem);
1659
1660     hres = IHTMLObjectElement_get_width(objelem, &v);
1661     ok(hres == S_OK, "get_width failed: %08x\n", hres);
1662     ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
1663     ok(!strcmp_wa(V_BSTR(&v), "300"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1664     VariantClear(&v);
1665
1666     hres = IHTMLObjectElement_get_height(objelem, &v);
1667     ok(hres == S_OK, "get_height failed: %08x\n", hres);
1668     ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
1669     ok(!strcmp_wa(V_BSTR(&v), "200"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1670     VariantClear(&v);
1671
1672     V_VT(&v) = VT_I4;
1673     V_I4(&v) = 400;
1674     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
1675     SET_EXPECT(Invoke_ENABLED);
1676     hres = IHTMLObjectElement_put_width(objelem, v);
1677     ok(hres == S_OK, "put_width failed: %08x\n", hres);
1678     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
1679     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
1680
1681     hres = IHTMLObjectElement_get_width(objelem, &v);
1682     ok(hres == S_OK, "get_width failed: %08x\n", hres);
1683     ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
1684     ok(!strcmp_wa(V_BSTR(&v), "400"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1685     VariantClear(&v);
1686
1687     V_VT(&v) = VT_I4;
1688     V_I4(&v) = 250;
1689     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
1690     SET_EXPECT(Invoke_ENABLED);
1691     hres = IHTMLObjectElement_put_height(objelem, v);
1692     ok(hres == S_OK, "put_height failed: %08x\n", hres);
1693     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
1694     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
1695
1696     hres = IHTMLObjectElement_get_height(objelem, &v);
1697     ok(hres == S_OK, "get_height failed: %08x\n", hres);
1698     ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
1699     ok(!strcmp_wa(V_BSTR(&v), "250"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1700     VariantClear(&v);
1701
1702     IHTMLObjectElement_Release(objelem);
1703 }
1704
1705 static void test_container(IHTMLDocument2 *doc_obj)
1706 {
1707     IHTMLWindow2 *parent_window, *html_window;
1708     IServiceProvider *serv_prov;
1709     IOleContainer *container;
1710     IHTMLDocument2 *doc;
1711     IUnknown *unk;
1712     HRESULT hres;
1713
1714     container = NULL;
1715     hres = IOleClientSite_GetContainer(client_site, &container);
1716     ok(hres == S_OK, "GetContainer failed: %08x\n", hres);
1717     ok(container != NULL, "container == NULL\n");
1718
1719     hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
1720     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1721     ok(parent_window != NULL, "parentWindow == NULL\n");
1722
1723     hres = IHTMLWindow2_get_document(parent_window, &doc);
1724     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1725     ok(doc != NULL, "doc == NULL\n");
1726     ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
1727     IHTMLDocument2_Release(doc);
1728
1729     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
1730     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1731
1732     hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
1733     ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08x\n", hres);
1734     todo_wine
1735     ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
1736     IHTMLWindow2_Release(html_window);
1737
1738     SET_EXPECT(QueryService_TestActiveX);
1739     hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
1740     ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08x\n", hres);
1741     ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
1742     CHECK_CALLED(QueryService_TestActiveX);
1743     IUnknown_Release(unk);
1744
1745     IServiceProvider_Release(serv_prov);
1746
1747     IHTMLWindow2_Release(parent_window);
1748     IOleContainer_Release(container);
1749 }
1750
1751 static void test_ui_activate(void)
1752 {
1753     IOleInPlaceSite *ip_site;
1754     HRESULT hres;
1755
1756     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1757     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1758
1759     SET_EXPECT(Invoke_ENABLED);
1760     hres = IOleInPlaceSite_OnUIActivate(ip_site);
1761     ok(hres == S_OK, "OnUIActivate failed: %08x\n", hres);
1762     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
1763
1764     IOleInPlaceSite_Release(ip_site);
1765 }
1766
1767 static HRESULT cs_qi(REFIID,void **);
1768 static IOleDocumentView *view;
1769
1770 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1771 {
1772     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1773
1774     if(!IsEqualGUID(&undocumented_frame_iid, riid))
1775         ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
1776
1777     *ppv = NULL;
1778     return E_NOINTERFACE;
1779 }
1780
1781 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1782 {
1783     return 2;
1784 }
1785
1786 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1787 {
1788     return 1;
1789 }
1790
1791 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1792 {
1793     return E_NOTIMPL;
1794 }
1795
1796 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1797 {
1798     return E_NOTIMPL;
1799 }
1800
1801 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1802 {
1803     return E_NOTIMPL;
1804 }
1805
1806 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1807         LPCBORDERWIDTHS pborderwidths)
1808 {
1809     return E_NOTIMPL;
1810 }
1811
1812 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1813         LPCBORDERWIDTHS pborderwidths)
1814 {
1815     return S_OK;
1816 }
1817
1818 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1819         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1820 {
1821     return S_OK;
1822 }
1823
1824 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1825         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1826 {
1827     return S_OK;
1828 }
1829
1830 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1831         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1832 {
1833     return E_NOTIMPL;
1834 }
1835
1836 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1837         HOLEMENU holemenu, HWND hwndActiveObject)
1838 {
1839     ok(0, "unexpected call\n");
1840     return E_NOTIMPL;
1841 }
1842
1843 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1844 {
1845     ok(0, "unexpected call\n");
1846     return E_NOTIMPL;
1847 }
1848
1849 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1850 {
1851     return S_OK;
1852 }
1853
1854 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1855 {
1856     return E_NOTIMPL;
1857 }
1858
1859 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1860 {
1861     ok(0, "unexpected call\n");
1862     return E_NOTIMPL;
1863 }
1864
1865 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1866     InPlaceFrame_QueryInterface,
1867     InPlaceFrame_AddRef,
1868     InPlaceFrame_Release,
1869     InPlaceFrame_GetWindow,
1870     InPlaceFrame_ContextSensitiveHelp,
1871     InPlaceFrame_GetBorder,
1872     InPlaceFrame_RequestBorderSpace,
1873     InPlaceFrame_SetBorderSpace,
1874     InPlaceFrame_SetActiveObject,
1875     InPlaceFrame_InsertMenus,
1876     InPlaceFrame_SetMenu,
1877     InPlaceFrame_RemoveMenus,
1878     InPlaceFrame_SetStatusText,
1879     InPlaceFrame_EnableModeless,
1880     InPlaceFrame_TranslateAccelerator
1881 };
1882
1883 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1884
1885 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1886     InPlaceFrame_QueryInterface,
1887     InPlaceFrame_AddRef,
1888     InPlaceFrame_Release,
1889     InPlaceFrame_GetWindow,
1890     InPlaceFrame_ContextSensitiveHelp,
1891     InPlaceFrame_GetBorder,
1892     InPlaceFrame_RequestBorderSpace,
1893     InPlaceFrame_SetBorderSpace,
1894     InPlaceUIWindow_SetActiveObject,
1895 };
1896
1897 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1898
1899 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1900 {
1901     return cs_qi(riid, ppv);
1902 }
1903
1904 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1905 {
1906     return 2;
1907 }
1908
1909 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1910 {
1911     return 1;
1912 }
1913
1914 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1915 {
1916     *phwnd = container_hwnd;
1917     return S_OK;
1918 }
1919
1920 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1921 {
1922     ok(0, "unexpected call\n");
1923     return E_NOTIMPL;
1924 }
1925
1926 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1927 {
1928     return S_OK;
1929 }
1930
1931 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1932 {
1933     return S_OK;
1934 }
1935
1936 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1937 {
1938     return S_OK;
1939 }
1940
1941 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1942         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1943         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1944 {
1945     static const RECT rect = {0,0,500,500};
1946
1947     *ppFrame = &InPlaceFrame;
1948     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1949     *lprcPosRect = rect;
1950     *lprcClipRect = rect;
1951
1952     lpFrameInfo->fMDIApp = FALSE;
1953     lpFrameInfo->hwndFrame = container_hwnd;
1954     lpFrameInfo->haccel = NULL;
1955     lpFrameInfo->cAccelEntries = 0;
1956
1957     return S_OK;
1958 }
1959
1960 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1961 {
1962     return E_NOTIMPL;
1963 }
1964
1965 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1966 {
1967     return S_OK;
1968 }
1969
1970 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1971 {
1972     return S_OK;
1973 }
1974
1975 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1976 {
1977     return E_NOTIMPL;
1978 }
1979
1980 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1981 {
1982     return E_NOTIMPL;
1983 }
1984
1985 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1986 {
1987     return E_NOTIMPL;
1988 }
1989
1990 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1991     InPlaceSite_QueryInterface,
1992     InPlaceSite_AddRef,
1993     InPlaceSite_Release,
1994     InPlaceSite_GetWindow,
1995     InPlaceSite_ContextSensitiveHelp,
1996     InPlaceSite_CanInPlaceActivate,
1997     InPlaceSite_OnInPlaceActivate,
1998     InPlaceSite_OnUIActivate,
1999     InPlaceSite_GetWindowContext,
2000     InPlaceSite_Scroll,
2001     InPlaceSite_OnUIDeactivate,
2002     InPlaceSite_OnInPlaceDeactivate,
2003     InPlaceSite_DiscardUndoState,
2004     InPlaceSite_DeactivateAndUndo,
2005     InPlaceSite_OnPosRectChange,
2006 };
2007
2008 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
2009
2010 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
2011 {
2012     return cs_qi(riid, ppv);
2013 }
2014
2015 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
2016 {
2017     return 2;
2018 }
2019
2020 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
2021 {
2022     return 1;
2023 }
2024
2025 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
2026 {
2027     ok(0, "unexpected call\n");
2028     return E_NOTIMPL;
2029 }
2030
2031 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
2032         IMoniker **ppmon)
2033 {
2034     ok(0, "unexpected call\n");
2035     return E_NOTIMPL;
2036 }
2037
2038 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
2039 {
2040     return E_NOTIMPL;
2041 }
2042
2043 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
2044 {
2045     ok(0, "unexpected call\n");
2046     return E_NOTIMPL;
2047 }
2048
2049 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
2050 {
2051     ok(0, "unexpected call\n");
2052     return E_NOTIMPL;
2053 }
2054
2055 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
2056 {
2057     ok(0, "unexpected call\n");
2058     return E_NOTIMPL;
2059 }
2060
2061 static const IOleClientSiteVtbl ClientSiteVtbl = {
2062     ClientSite_QueryInterface,
2063     ClientSite_AddRef,
2064     ClientSite_Release,
2065     ClientSite_SaveObject,
2066     ClientSite_GetMoniker,
2067     ClientSite_GetContainer,
2068     ClientSite_ShowObject,
2069     ClientSite_OnShowWindow,
2070     ClientSite_RequestNewObjectLayout
2071 };
2072
2073 static IOleClientSite ClientSite = { &ClientSiteVtbl };
2074
2075 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
2076 {
2077     return cs_qi(riid, ppv);
2078 }
2079
2080 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
2081 {
2082     return 2;
2083 }
2084
2085 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
2086 {
2087     return 1;
2088 }
2089
2090 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
2091 {
2092     RECT rect = {0,0,400,500};
2093     IOleDocument *document;
2094     HRESULT hres;
2095
2096     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
2097     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
2098
2099     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
2100     IOleDocument_Release(document);
2101     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
2102
2103     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
2104     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
2105
2106     hres = IOleDocumentView_UIActivate(view, TRUE);
2107     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2108
2109     hres = IOleDocumentView_SetRect(view, &rect);
2110     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
2111
2112     hres = IOleDocumentView_Show(view, TRUE);
2113     ok(hres == S_OK, "Show failed: %08x\n", hres);
2114
2115     return S_OK;
2116 }
2117
2118 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
2119     DocumentSite_QueryInterface,
2120     DocumentSite_AddRef,
2121     DocumentSite_Release,
2122     DocumentSite_ActivateMe
2123 };
2124
2125 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
2126
2127 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
2128                                                      REFIID riid, void **ppv)
2129 {
2130     return cs_qi(riid, ppv);
2131 }
2132
2133 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
2134 {
2135     return 2;
2136 }
2137
2138 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
2139 {
2140     return 1;
2141 }
2142
2143 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
2144         REFIID riid, void **ppv)
2145 {
2146     if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
2147         CHECK_EXPECT(QueryService_TestActiveX);
2148         ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
2149         *ppv = &OleObject;
2150         return S_OK;
2151     }
2152
2153     *ppv = NULL;
2154     return E_NOINTERFACE;
2155 }
2156
2157 static const IServiceProviderVtbl ServiceProviderVtbl = {
2158     ServiceProvider_QueryInterface,
2159     ServiceProvider_AddRef,
2160     ServiceProvider_Release,
2161     ServiceProvider_QueryService
2162 };
2163
2164 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
2165
2166 static HRESULT cs_qi(REFIID riid, void **ppv)
2167 {
2168     *ppv = NULL;
2169
2170     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
2171         *ppv = &ClientSite;
2172     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
2173         *ppv = &DocumentSite;
2174     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
2175         *ppv = &InPlaceSite;
2176     else if(IsEqualGUID(riid, &IID_IServiceProvider))
2177         *ppv = &ServiceProvider;
2178
2179     return *ppv ? S_OK : E_NOINTERFACE;
2180 }
2181
2182 static IHTMLDocument2 *notif_doc;
2183 static BOOL doc_complete;
2184
2185 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
2186         REFIID riid, void**ppv)
2187 {
2188     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
2189         *ppv = iface;
2190         return S_OK;
2191     }
2192
2193     ok(0, "unexpected call\n");
2194     return E_NOINTERFACE;
2195 }
2196
2197 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
2198 {
2199     return 2;
2200 }
2201
2202 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
2203 {
2204     return 1;
2205 }
2206
2207 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
2208 {
2209     if(dispID == DISPID_READYSTATE){
2210         BSTR state;
2211         HRESULT hres;
2212
2213         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
2214
2215         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
2216         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
2217
2218         if(!lstrcmpW(state, completeW))
2219             doc_complete = TRUE;
2220
2221         SysFreeString(state);
2222     }
2223
2224     return S_OK;
2225 }
2226
2227 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
2228 {
2229     ok(0, "unexpected call\n");
2230     return E_NOTIMPL;
2231 }
2232
2233 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
2234     PropertyNotifySink_QueryInterface,
2235     PropertyNotifySink_AddRef,
2236     PropertyNotifySink_Release,
2237     PropertyNotifySink_OnChanged,
2238     PropertyNotifySink_OnRequestEdit
2239 };
2240
2241 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
2242
2243 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
2244 {
2245     IPersistStreamInit *init;
2246     IStream *stream;
2247     HGLOBAL mem;
2248     SIZE_T len;
2249     HRESULT hr;
2250
2251     notif_doc = doc;
2252
2253     doc_complete = FALSE;
2254     len = strlen(str);
2255     mem = GlobalAlloc(0, len);
2256     memcpy(mem, str, len);
2257     hr = CreateStreamOnHGlobal(mem, TRUE, &stream);
2258     ok(hr == S_OK, "Failed to create a stream, hr %#x.\n", hr);
2259
2260     hr = IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
2261     ok(hr == S_OK, "Failed to get IPersistStreamInit, hr %#x.\n", hr);
2262
2263     IPersistStreamInit_Load(init, stream);
2264     IPersistStreamInit_Release(init);
2265     IStream_Release(stream);
2266 }
2267
2268 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
2269 {
2270     IConnectionPointContainer *container;
2271     IConnectionPoint *cp;
2272     DWORD cookie;
2273     HRESULT hres;
2274
2275     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
2276     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
2277
2278     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
2279     IConnectionPointContainer_Release(container);
2280     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
2281
2282     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
2283     IConnectionPoint_Release(cp);
2284     ok(hres == S_OK, "Advise failed: %08x\n", hres);
2285 }
2286
2287 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
2288 {
2289     IOleObject *oleobj;
2290     HRESULT hres;
2291
2292     if(!set && view) {
2293         IOleDocumentView_Show(view, FALSE);
2294         IOleDocumentView_CloseView(view, 0);
2295         IOleDocumentView_SetInPlaceSite(view, NULL);
2296         IOleDocumentView_Release(view);
2297         view = NULL;
2298     }
2299
2300     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
2301     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
2302
2303     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
2304     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
2305
2306     if(set) {
2307         IHlinkTarget *hlink;
2308
2309         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
2310         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
2311
2312         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
2313         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
2314
2315         IHlinkTarget_Release(hlink);
2316     }
2317
2318     IOleObject_Release(oleobj);
2319 }
2320 static IHTMLDocument2 *create_document(void)
2321 {
2322     IHTMLDocument2 *doc;
2323     HRESULT hres;
2324
2325     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2326             &IID_IHTMLDocument2, (void**)&doc);
2327     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2328
2329     return doc;
2330 }
2331
2332 static IHTMLDocument2 *create_doc(const char *str)
2333 {
2334     IHTMLDocument2 *doc;
2335     MSG msg;
2336
2337     doc = create_document();
2338     set_client_site(doc, TRUE);
2339     doc_load_string(doc, str);
2340     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2341
2342     while(!doc_complete && GetMessageW(&msg, NULL, 0, 0)) {
2343         TranslateMessage(&msg);
2344         DispatchMessageW(&msg);
2345     }
2346
2347     return doc;
2348 }
2349
2350 static void release_doc(IHTMLDocument2 *doc)
2351 {
2352     ULONG ref;
2353
2354     set_client_site(doc, FALSE);
2355     ref = IHTMLDocument2_Release(doc);
2356     ok(!ref || broken(ref == 1) /* Vista */, "ref = %d\n", ref);
2357
2358     if(client_site) {
2359         IOleClientSite_Release(client_site);
2360         client_site = NULL;
2361     }
2362
2363     if(plugin_hwnd) {
2364         DestroyWindow(plugin_hwnd);
2365         plugin_hwnd = NULL;
2366     }
2367
2368     ok(!activex_refcnt, "activex_refcnt = %d\n", activex_refcnt);
2369 }
2370
2371 static void init_test(int behavior)
2372 {
2373     plugin_behavior = behavior;
2374
2375     activex_refcnt = 0;
2376     no_quickact = behavior == TEST_NOQUICKACT || behavior == TEST_DISPONLY;
2377     have_container = TRUE;
2378 }
2379
2380 static void test_event_call(void)
2381 {
2382     VARIANT res, args[2];
2383     DISPPARAMS dp = {args};
2384     EXCEPINFO ei = {0};
2385     HRESULT hres;
2386
2387     V_VT(&res) = VT_EMPTY;
2388     hres = IDispatch_Invoke(sink_disp, 1, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
2389     ok(hres == S_OK, "Invoke failed: %08x\n", hres);
2390     ok(V_VT(&res) == VT_I4 && V_I4(&res) == 6, "unexpected result\n");
2391
2392     V_VT(args) = VT_I4;
2393     V_I4(args) = 2;
2394     V_VT(args+1) = VT_I4;
2395     V_I4(args+1) = 3;
2396     dp.cArgs = 2;
2397     V_VT(&res) = VT_EMPTY;
2398     hres = IDispatch_Invoke(sink_disp, 2, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
2399     ok(hres == S_OK, "Invoke failed: %08x\n", hres);
2400     ok(V_VT(&res) == VT_I4 && V_I4(&res) == 7, "unexpected result: %d\n", V_I4(&res));
2401
2402     V_VT(&res) = VT_ERROR;
2403     hres = IDispatch_Invoke(sink_disp, 10, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
2404     ok(hres == S_OK, "Invoke failed: %08x\n", hres);
2405     ok(V_VT(&res) == VT_EMPTY, "V_VT(res) = %d\n", V_VT(&res));
2406 }
2407
2408 static void test_flash_ax(void)
2409 {
2410     IHTMLDocument2 *doc;
2411     IOleClientSite *cs;
2412
2413     init_test(TEST_FLASH);
2414
2415     SET_EXPECT(CreateInstance);
2416     SET_EXPECT(FreezeEvents_TRUE);
2417     SET_EXPECT(QuickActivate);
2418     SET_EXPECT(FreezeEvents_FALSE);
2419     SET_EXPECT(IPersistPropertyBag_Load);
2420     SET_EXPECT(Invoke_READYSTATE);
2421     SET_EXPECT(Invoke_SECURITYCTX);
2422     SET_EXPECT(Invoke_SCRIPTCALL);
2423     SET_EXPECT(SetExtent);
2424     SET_EXPECT(GetExtent);
2425     SET_EXPECT(DoVerb);
2426
2427     doc = create_doc(object_ax_str);
2428
2429     CHECK_CALLED(CreateInstance);
2430     todo_wine
2431     CHECK_CALLED(FreezeEvents_TRUE);
2432     CHECK_CALLED(QuickActivate);
2433     todo_wine
2434     CHECK_CALLED(FreezeEvents_FALSE);
2435     CHECK_CALLED(IPersistPropertyBag_Load);
2436     CHECK_CALLED(Invoke_READYSTATE);
2437     CHECK_CALLED(Invoke_SECURITYCTX);
2438     CHECK_CALLED(Invoke_SCRIPTCALL);
2439     todo_wine
2440     CHECK_CALLED(SetExtent);
2441     todo_wine
2442     CHECK_CALLED(GetExtent);
2443     CHECK_CALLED(DoVerb);
2444
2445     /* Set in DoVerb */
2446     CHECK_CALLED(InPlaceObject_GetWindow);
2447     CHECK_CALLED(SetObjectRects);
2448
2449     test_ui_activate();
2450     test_container(notif_doc);
2451     test_object_elem(notif_doc);
2452
2453     IOleClientSite_AddRef(client_site);
2454     cs = client_site;
2455
2456     SET_EXPECT(UIDeactivate);
2457     SET_EXPECT(Invoke_ENABLED);
2458     SET_EXPECT(Invoke_VALID);
2459     SET_EXPECT(InPlaceDeactivate);
2460     SET_EXPECT(Close);
2461     SET_EXPECT(SetClientSite_NULL);
2462     release_doc(doc);
2463     CHECK_CALLED(UIDeactivate);
2464     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
2465     todo_wine
2466     CHECK_CALLED(Invoke_VALID);
2467     CHECK_CALLED(InPlaceDeactivate);
2468     CHECK_CALLED(Close);
2469     CHECK_CALLED(SetClientSite_NULL);
2470
2471     IOleClientSite_Release(cs);
2472 }
2473
2474 static void test_noquickact_ax(void)
2475 {
2476     IHTMLDocument2 *doc;
2477
2478     init_test(TEST_NOQUICKACT);
2479
2480     SET_EXPECT(CreateInstance);
2481     SET_EXPECT(FreezeEvents_TRUE);
2482     SET_EXPECT(GetMiscStatus);
2483     SET_EXPECT(SetClientSite);
2484     SET_EXPECT(SetAdvise);
2485     SET_EXPECT(GetViewStatus);
2486     SET_EXPECT(FreezeEvents_FALSE);
2487     SET_EXPECT(Invoke_READYSTATE);
2488     SET_EXPECT(Invoke_SECURITYCTX);
2489     SET_EXPECT(Invoke_SCRIPTCALL);
2490     SET_EXPECT(SetExtent);
2491     SET_EXPECT(GetExtent);
2492     SET_EXPECT(DoVerb);
2493
2494     doc = create_doc(object_ax_str);
2495
2496     CHECK_CALLED(CreateInstance);
2497     todo_wine CHECK_CALLED(FreezeEvents_TRUE);
2498     CHECK_CALLED(GetMiscStatus);
2499     CHECK_CALLED(SetClientSite);
2500     CHECK_CALLED(SetAdvise);
2501     CHECK_CALLED(GetViewStatus);
2502     todo_wine CHECK_CALLED(FreezeEvents_FALSE);
2503     CHECK_CALLED(Invoke_READYSTATE);
2504     CHECK_CALLED(Invoke_SECURITYCTX);
2505     CHECK_CALLED(Invoke_SCRIPTCALL);
2506     todo_wine CHECK_CALLED(SetExtent);
2507     todo_wine CHECK_CALLED(GetExtent);
2508     CHECK_CALLED(DoVerb);
2509
2510     /* Set in DoVerb */
2511     CHECK_CALLED(InPlaceObject_GetWindow);
2512     CHECK_CALLED(SetObjectRects);
2513
2514     SET_EXPECT(InPlaceDeactivate);
2515     SET_EXPECT(Close);
2516     SET_EXPECT(SetClientSite_NULL);
2517     release_doc(doc);
2518     CHECK_CALLED(InPlaceDeactivate);
2519     CHECK_CALLED(Close);
2520     CHECK_CALLED(SetClientSite_NULL);
2521 }
2522
2523 static void test_event_binding(void)
2524 {
2525     IHTMLDocument2 *doc;
2526
2527     init_test(TEST_FLASH);
2528
2529     SET_EXPECT(CreateInstance);
2530     SET_EXPECT(FreezeEvents_TRUE);
2531     SET_EXPECT(QuickActivate);
2532     SET_EXPECT(FreezeEvents_FALSE);
2533     SET_EXPECT(IPersistPropertyBag_Load);
2534     SET_EXPECT(Invoke_READYSTATE);
2535     SET_EXPECT(SetExtent);
2536     SET_EXPECT(GetExtent);
2537     SET_EXPECT(DoVerb);
2538
2539     SET_EXPECT(GetClassInfo);
2540     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
2541     SET_EXPECT(FindConnectionPoint);
2542     SET_EXPECT(Advise);
2543
2544     doc = create_doc(event_binding_str);
2545
2546     CHECK_CALLED(CreateInstance);
2547     todo_wine
2548     CHECK_CALLED(FreezeEvents_TRUE);
2549     CHECK_CALLED(QuickActivate);
2550     todo_wine
2551     CHECK_CALLED(FreezeEvents_FALSE);
2552     CHECK_CALLED(IPersistPropertyBag_Load);
2553     CHECK_CALLED(Invoke_READYSTATE);
2554     todo_wine
2555     CHECK_CALLED(SetExtent);
2556     todo_wine
2557     CHECK_CALLED(GetExtent);
2558     CHECK_CALLED(DoVerb);
2559
2560     /* Set in DoVerb */
2561     CHECK_CALLED(InPlaceObject_GetWindow);
2562     CHECK_CALLED(SetObjectRects);
2563
2564     CHECK_CALLED(GetClassInfo);
2565     todo_wine
2566     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
2567     CHECK_CALLED(FindConnectionPoint);
2568     CHECK_CALLED(Advise);
2569
2570     test_event_call();
2571
2572     SET_EXPECT(InPlaceDeactivate);
2573     SET_EXPECT(Close);
2574     SET_EXPECT(SetClientSite_NULL);
2575     SET_EXPECT(FindConnectionPoint);
2576     SET_EXPECT(Unadvise);
2577     release_doc(doc);
2578     CHECK_CALLED(InPlaceDeactivate);
2579     CHECK_CALLED(Close);
2580     CHECK_CALLED(SetClientSite_NULL);
2581     CHECK_CALLED(FindConnectionPoint);
2582     CHECK_CALLED(Unadvise);
2583 }
2584
2585 static void test_nooleobj_ax(void)
2586 {
2587     IHTMLDocument2 *doc;
2588
2589     init_test(TEST_DISPONLY);
2590
2591     SET_EXPECT(CreateInstance);
2592     SET_EXPECT(Invoke_READYSTATE);
2593     SET_EXPECT(Invoke_SECURITYCTX);
2594     SET_EXPECT(Invoke_SCRIPTCALL);
2595
2596     doc = create_doc(object_ax_str);
2597
2598     CHECK_CALLED(CreateInstance);
2599     CHECK_CALLED(Invoke_READYSTATE);
2600     CHECK_CALLED(Invoke_SECURITYCTX);
2601     CHECK_CALLED(Invoke_SCRIPTCALL);
2602
2603     release_doc(doc);
2604 }
2605
2606 static void test_exec_script(IHTMLDocument2 *doc, const char *codea, const char *langa)
2607 {
2608     IHTMLWindow2 *window;
2609     BSTR code, lang;
2610     VARIANT v;
2611     HRESULT hres;
2612
2613     hres = IHTMLDocument2_get_parentWindow(doc, &window);
2614     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
2615
2616     code = a2bstr(codea);
2617     lang = a2bstr(langa);
2618
2619     hres = IHTMLWindow2_execScript(window, code, lang, &v);
2620     ok(hres == S_OK, "execScript failed: %08x\n", hres);
2621     SysFreeString(lang);
2622     VariantClear(&v);
2623
2624     IHTMLWindow2_Release(window);
2625 }
2626
2627 static void test_create_element(void)
2628 {
2629     IHTMLDocument2 *doc;
2630
2631     init_test(TEST_FLASH);
2632
2633     doc = create_doc("<html></html>");
2634
2635     have_container = FALSE;
2636
2637     SET_EXPECT(CreateInstance);
2638     SET_EXPECT(FreezeEvents_TRUE);
2639     SET_EXPECT(QuickActivate);
2640     SET_EXPECT(IPersistPropertyBag_InitNew);
2641     SET_EXPECT(Invoke_READYSTATE);
2642     SET_EXPECT(FreezeEvents_FALSE);
2643
2644     test_exec_script(doc,
2645                      "var test_elem = document.createElement('object');"
2646                      "test_elem.classid = 'CLSID:178fc163-f585-4e24-9c13-4bb7f6680746';",
2647                      "javascript");
2648
2649     CHECK_CALLED(CreateInstance);
2650     todo_wine CHECK_CALLED(FreezeEvents_TRUE);
2651     CHECK_CALLED(QuickActivate);
2652     CHECK_CALLED(IPersistPropertyBag_InitNew);
2653     CHECK_CALLED(Invoke_READYSTATE);
2654     todo_wine CHECK_CALLED(FreezeEvents_FALSE);
2655
2656     have_container = TRUE;
2657
2658     SET_EXPECT(DoVerb);
2659     test_exec_script(doc,
2660                      "document.body.appendChild(test_elem);",
2661                      "javascript");
2662     todo_wine CHECK_CALLED(DoVerb);
2663
2664     SET_EXPECT(InPlaceDeactivate);
2665     SET_EXPECT(Close);
2666     SET_EXPECT(SetClientSite_NULL);
2667     release_doc(doc);
2668     todo_wine CHECK_CALLED(InPlaceDeactivate);
2669     CHECK_CALLED(Close);
2670     CHECK_CALLED(SetClientSite_NULL);
2671 }
2672
2673 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2674 {
2675     return DefWindowProcW(hwnd, msg, wParam, lParam);
2676 }
2677
2678 static HWND create_container_window(void)
2679 {
2680     static const WCHAR html_document_testW[] =
2681         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
2682     static WNDCLASSEXW wndclass = {
2683         sizeof(WNDCLASSEXW),
2684         0,
2685         wnd_proc,
2686         0, 0, NULL, NULL, NULL, NULL, NULL,
2687         html_document_testW,
2688         NULL
2689     };
2690
2691     RegisterClassExW(&wndclass);
2692     return CreateWindowW(html_document_testW, html_document_testW,
2693             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2694             515, 530, NULL, NULL, NULL, NULL);
2695 }
2696
2697 static void load_typelib(void)
2698 {
2699     WCHAR path[MAX_PATH];
2700     ITypeLib *typelib;
2701     HRESULT hres;
2702
2703     GetModuleFileNameW(NULL, path, MAX_PATH);
2704
2705     hres = LoadTypeLib(path, &typelib);
2706     ok(hres == S_OK, "LoadTypeLib failed: %08x\n", hres);
2707
2708     hres = ITypeLib_GetTypeInfoOfGuid(typelib, &DIID_DispActiveXTest, &actxtest_typeinfo);
2709     ok(hres == S_OK, "GetTypeInfoOfGuid(DIID_DispActiveXTest) failed: %08x\n", hres);
2710
2711     hres = ITypeLib_GetTypeInfoOfGuid(typelib, &CLSID_ActiveXTest, &class_typeinfo);
2712     ok(hres == S_OK, "GetTypeInfoOfGuid(CLSID_ActiveXTest) failed: %08x\n", hres);
2713
2714     ITypeLib_Release(typelib);
2715 }
2716
2717 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
2718 {
2719     HKEY hkey;
2720     DWORD res;
2721
2722     if(!init) {
2723         RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
2724         return TRUE;
2725     }
2726
2727     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
2728     if(res != ERROR_SUCCESS)
2729         return FALSE;
2730
2731     if(def_value)
2732         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
2733
2734     RegCloseKey(hkey);
2735
2736     return res == ERROR_SUCCESS;
2737 }
2738
2739 static BOOL init_registry(BOOL init)
2740 {
2741     return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
2742         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
2743                     NULL, init)
2744         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
2745                     NULL, init);
2746 }
2747
2748 static BOOL register_activex(void)
2749 {
2750     DWORD regid;
2751     HRESULT hres;
2752
2753     if(!init_registry(TRUE)) {
2754         init_registry(FALSE);
2755         return FALSE;
2756     }
2757
2758     hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
2759             CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2760     ok(hres == S_OK, "Could not register control: %08x\n", hres);
2761
2762     return TRUE;
2763 }
2764
2765 static BOOL check_ie(void)
2766 {
2767     IHTMLDocument5 *doc;
2768     HRESULT hres;
2769
2770     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2771             &IID_IHTMLDocument5, (void**)&doc);
2772     if(FAILED(hres))
2773         return FALSE;
2774
2775     IHTMLDocument5_Release(doc);
2776     return TRUE;
2777 }
2778
2779 START_TEST(activex)
2780 {
2781     CoInitialize(NULL);
2782
2783     if(!check_ie()) {
2784         CoUninitialize();
2785         win_skip("Too old IE\n");
2786         return;
2787     }
2788
2789     if(is_ie_hardened()) {
2790         CoUninitialize();
2791         win_skip("IE running in Enhanced Security Configuration\n");
2792         return;
2793     }
2794
2795     init_wrapped_iface();
2796     load_typelib();
2797     container_hwnd = create_container_window();
2798     ShowWindow(container_hwnd, SW_SHOW);
2799
2800     if(register_activex()) {
2801         trace("Testing emulated flash embedding...\n");
2802         test_flash_ax();
2803         trace("Testing plugin without IQuickActivate iface...\n");
2804         test_noquickact_ax();
2805         trace("Testing plugin with IDispatch iface only...\n");
2806         test_nooleobj_ax();
2807         trace("Testing event object binding...\n");
2808         test_event_binding();
2809         trace("Testing createElement(object)...\n");
2810         test_create_element();
2811         init_registry(FALSE);
2812     }else {
2813         skip("Could not register ActiveX\n");
2814     }
2815
2816     if(actxtest_typeinfo)
2817         ITypeInfo_Release(actxtest_typeinfo);
2818     if(class_typeinfo)
2819         ITypeInfo_Release(class_typeinfo);
2820     DestroyWindow(container_hwnd);
2821     CoUninitialize();
2822 }