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