git.oblomov.eu Git - wine/blob - dlls/shdocvw/tests/webbrowser.c

   1 /*
   2  * Copyright 2006 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
  21 #include <wine/test.h>
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "ole2.h"
  27 #include "exdisp.h"
  28 #include "htiframe.h"
  29
  30 #define DEFINE_EXPECT(func) \
  31     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  32
  33 #define SET_EXPECT(func) \
  34     expect_ ## func = TRUE
  35
  36 #define CHECK_EXPECT(func) \
  37     do { \
  38         ok(expect_ ##func, "unexpected call " #func "\n"); \
  39         expect_ ## func = FALSE; \
  40         called_ ## func = TRUE; \
  41     }while(0)
  42
  43 #define CHECK_EXPECT2(func) \
  44     do { \
  45         ok(expect_ ##func, "unexpected call " #func "\n"); \
  46         called_ ## func = TRUE; \
  47     }while(0)
  48
  49 #define CHECK_CALLED(func) \
  50     do { \
  51         ok(called_ ## func, "expected " #func "\n"); \
  52         expect_ ## func = called_ ## func = FALSE; \
  53     }while(0)
  54
  55 DEFINE_EXPECT(GetContainer);
  56 DEFINE_EXPECT(Site_GetWindow);
  57 DEFINE_EXPECT(ShowObject);
  58 DEFINE_EXPECT(CanInPlaceActivate);
  59 DEFINE_EXPECT(OnInPlaceActivate);
  60 DEFINE_EXPECT(OnUIActivate);
  61 DEFINE_EXPECT(GetWindowContext);
  62 DEFINE_EXPECT(Frame_GetWindow);
  63 DEFINE_EXPECT(Frame_SetActiveObject);
  64 DEFINE_EXPECT(UIWindow_SetActiveObject);
  65 DEFINE_EXPECT(SetMenu);
  66
  67 static const WCHAR wszItem[] = {'i','t','e','m',0};
  68
  69 static HWND container_hwnd, shell_embedding_hwnd;
  70
  71 static HRESULT QueryInterface(REFIID,void**);
  72
  73 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
  74 {
  75     if(IsEqualGUID(&IID_ITargetContainer, riid))
  76         return E_NOINTERFACE; /* TODO */
  77     if(IsEqualGUID(&IID_IOleCommandTarget, riid))
  78         return E_NOINTERFACE; /* TODO */
  79
  80     ok(0, "unexpected call\n");
  81     return E_NOINTERFACE;
  82 }
  83
  84 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
  85 {
  86     return 2;
  87 }
  88
  89 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
  90 {
  91     return 1;
  92 }
  93
  94 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc,
  95         LPOLESTR pszDiaplayName, ULONG *pchEaten, IMoniker **ppmkOut)
  96 {
  97     ok(0, "unexpected call\n");
  98     return E_NOTIMPL;
  99 }
 100
 101 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags,
 102         IEnumUnknown **ppenum)
 103 {
 104     ok(0, "unexpected call\n");
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
 109 {
 110     ok(0, "unexpected call\n");
 111     return E_NOTIMPL;
 112 }
 113
 114 static const IOleContainerVtbl OleContainerVtbl = {
 115     OleContainer_QueryInterface,
 116     OleContainer_AddRef,
 117     OleContainer_Release,
 118     OleContainer_ParseDisplayName,
 119     OleContainer_EnumObjects,
 120     OleContainer_LockContainer
 121 };
 122
 123 static IOleContainer OleContainer = { &OleContainerVtbl };
 124
 125 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 126 {
 127     return QueryInterface(riid, ppv);
 128 }
 129
 130 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
 131 {
 132     return 2;
 133 }
 134
 135 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
 136 {
 137     return 1;
 138 }
 139
 140 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
 141 {
 142     ok(0, "unexpected call\n");
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAsign, DWORD dwWhichMoniker,
 147         IMoniker **ppmon)
 148 {
 149     ok(0, "unexpected call\n");
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 154 {
 155     CHECK_EXPECT(GetContainer);
 156
 157     ok(ppContainer != NULL, "ppContainer == NULL\n");
 158     if(ppContainer)
 159         *ppContainer = &OleContainer;
 160
 161     return S_OK;
 162 }
 163
 164 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
 165 {
 166     CHECK_EXPECT(ShowObject);
 167     return S_OK;
 168 }
 169
 170 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 171 {
 172     ok(0, "unexpected call\n");
 173     return E_NOTIMPL;
 174 }
 175
 176 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 177 {
 178     ok(0, "unexpected call\n");
 179     return E_NOTIMPL;
 180 }
 181
 182 static const IOleClientSiteVtbl ClientSiteVtbl = {
 183     ClientSite_QueryInterface,
 184     ClientSite_AddRef,
 185     ClientSite_Release,
 186     ClientSite_SaveObject,
 187     ClientSite_GetMoniker,
 188     ClientSite_GetContainer,
 189     ClientSite_ShowObject,
 190     ClientSite_OnShowWindow,
 191     ClientSite_RequestNewObjectLayout
 192 };
 193
 194 static HRESULT WINAPI InPlaceUIWindow_QueryInterface(IOleInPlaceFrame *iface,
 195                                                      REFIID riid, void **ppv)
 196 {
 197     ok(0, "unexpected call\n");
 198     return E_NOINTERFACE;
 199 }
 200
 201 static ULONG WINAPI InPlaceUIWindow_AddRef(IOleInPlaceFrame *iface)
 202 {
 203     return 2;
 204 }
 205
 206 static ULONG WINAPI InPlaceUIWindow_Release(IOleInPlaceFrame *iface)
 207 {
 208     return 1;
 209 }
 210
 211 static HRESULT WINAPI InPlaceUIWindow_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 212 {
 213     ok(0, "unexpected call\n");
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 218 {
 219     CHECK_EXPECT(Frame_GetWindow);
 220     ok(phwnd != NULL, "phwnd == NULL\n");
 221     if(phwnd)
 222         *phwnd = container_hwnd;
 223     return S_OK;
 224 }
 225
 226 static HRESULT WINAPI InPlaceUIWindow_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 227 {
 228     ok(0, "unexpected call\n");
 229     return E_NOTIMPL;
 230 }
 231
 232 static HRESULT WINAPI InPlaceUIWindow_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 233 {
 234     ok(0, "unexpected call\n");
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI InPlaceUIWindow_RequestBorderSpace(IOleInPlaceFrame *iface,
 239         LPCBORDERWIDTHS pborderwidths)
 240 {
 241     ok(0, "unexpected call\n");
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI InPlaceUIWindow_SetBorderSpace(IOleInPlaceFrame *iface,
 246         LPCBORDERWIDTHS pborderwidths)
 247 {
 248     ok(0, "unexpected call\n");
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
 253         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 254 {
 255     CHECK_EXPECT(UIWindow_SetActiveObject);
 256     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 257     ok(!lstrcmpW(pszObjName, wszItem), "unexpected pszObjName\n");
 258     return S_OK;
 259 }
 260
 261 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 262         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 263 {
 264     CHECK_EXPECT(Frame_SetActiveObject);
 265     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 266     ok(!lstrcmpW(pszObjName, wszItem), "unexpected pszObjName\n");
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 271         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 272 {
 273     ok(0, "unexpected call\n");
 274     return E_NOTIMPL;
 275 }
 276
 277 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 278         HOLEMENU holemenu, HWND hwndActiveObject)
 279 {
 280     CHECK_EXPECT(SetMenu);
 281     ok(hmenuShared == NULL, "hmenuShared=%p\n", hmenuShared);
 282     ok(holemenu == NULL, "holemenu=%p\n", holemenu);
 283     ok(hwndActiveObject == shell_embedding_hwnd, "hwndActiveObject=%p, expected %p\n",
 284        hwndActiveObject, shell_embedding_hwnd);
 285     return S_OK;
 286 }
 287
 288 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 289 {
 290     ok(0, "unexpected call\n");
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 295 {
 296     ok(0, "unexpected call\n");
 297     return E_NOTIMPL;
 298 }
 299
 300 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 301 {
 302     ok(0, "unexpected call\n");
 303     return E_NOTIMPL;
 304 }
 305
 306 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 307 {
 308     ok(0, "unexpected call\n");
 309     return E_NOTIMPL;
 310 }
 311
 312 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
 313     InPlaceUIWindow_QueryInterface,
 314     InPlaceUIWindow_AddRef,
 315     InPlaceUIWindow_Release,
 316     InPlaceUIWindow_GetWindow,
 317     InPlaceUIWindow_ContextSensitiveHelp,
 318     InPlaceUIWindow_GetBorder,
 319     InPlaceUIWindow_RequestBorderSpace,
 320     InPlaceUIWindow_SetBorderSpace,
 321     InPlaceUIWindow_SetActiveObject,
 322 };
 323
 324 static IOleInPlaceUIWindow InPlaceUIWindow = { (IOleInPlaceUIWindowVtbl*)&InPlaceUIWindowVtbl };
 325
 326 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 327     InPlaceUIWindow_QueryInterface,
 328     InPlaceUIWindow_AddRef,
 329     InPlaceUIWindow_Release,
 330     InPlaceFrame_GetWindow,
 331     InPlaceUIWindow_ContextSensitiveHelp,
 332     InPlaceUIWindow_GetBorder,
 333     InPlaceUIWindow_RequestBorderSpace,
 334     InPlaceUIWindow_SetBorderSpace,
 335     InPlaceFrame_SetActiveObject,
 336     InPlaceFrame_InsertMenus,
 337     InPlaceFrame_SetMenu,
 338     InPlaceFrame_RemoveMenus,
 339     InPlaceFrame_SetStatusText,
 340     InPlaceFrame_EnableModeless,
 341     InPlaceFrame_TranslateAccelerator
 342 };
 343
 344 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 345
 346 static IOleClientSite ClientSite = { &ClientSiteVtbl };
 347
 348 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSiteEx *iface, REFIID riid, void **ppv)
 349 {
 350     return QueryInterface(riid, ppv);
 351 }
 352
 353 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSiteEx *iface)
 354 {
 355     return 2;
 356 }
 357
 358 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSiteEx *iface)
 359 {
 360     return 1;
 361 }
 362
 363 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSiteEx *iface, HWND *phwnd)
 364 {
 365     CHECK_EXPECT(Site_GetWindow);
 366     ok(phwnd != NULL, "phwnd == NULL\n");
 367     if(phwnd)
 368         *phwnd = container_hwnd;
 369     return S_OK;
 370 }
 371
 372 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSiteEx *iface, BOOL fEnterMode)
 373 {
 374     ok(0, "unexpected call\n");
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSiteEx *iface)
 379 {
 380     CHECK_EXPECT(CanInPlaceActivate);
 381     return S_OK;
 382 }
 383
 384 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSiteEx *iface)
 385 {
 386     CHECK_EXPECT(OnInPlaceActivate);
 387     return S_OK;
 388 }
 389
 390 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSiteEx *iface)
 391 {
 392     CHECK_EXPECT(OnUIActivate);
 393     return S_OK;
 394 }
 395
 396 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSiteEx *iface,
 397         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 398         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 399 {
 400     static const RECT pos_rect = {2,1,1002,901};
 401     static const RECT clip_rect = {10,10,990,890};
 402
 403     CHECK_EXPECT(GetWindowContext);
 404
 405     ok(ppFrame != NULL, "ppFrame = NULL\n");
 406     if(ppFrame)
 407         *ppFrame = &InPlaceFrame;
 408
 409     ok(ppDoc != NULL, "ppDoc = NULL\n");
 410     if(ppDoc)
 411         *ppDoc = &InPlaceUIWindow;
 412
 413     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
 414     if(lprcPosRect)
 415         memcpy(lprcPosRect, &pos_rect, sizeof(RECT));
 416
 417     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
 418     if(lprcClipRect)
 419         memcpy(lprcClipRect, &clip_rect, sizeof(RECT));
 420
 421     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
 422     if(lpFrameInfo) {
 423         lpFrameInfo->cb = sizeof(*lpFrameInfo);
 424         lpFrameInfo->fMDIApp = FALSE;
 425         lpFrameInfo->hwndFrame = container_hwnd;
 426         lpFrameInfo->haccel = NULL;
 427         lpFrameInfo->cAccelEntries = 0;
 428     }
 429
 430     return S_OK;
 431 }
 432
 433 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSiteEx *iface, SIZE scrollExtant)
 434 {
 435     ok(0, "unexpected call\n");
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSiteEx *iface, BOOL fUndoable)
 440 {
 441     ok(0, "unexpected call\n");
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSiteEx *iface)
 446 {
 447     ok(0, "unexpected call\n");
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSiteEx *iface)
 452 {
 453     ok(0, "unexpected call\n");
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSiteEx *iface)
 458 {
 459     ok(0, "unexpected call\n");
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSiteEx *iface, LPCRECT lprcPosRect)
 464 {
 465     ok(0, "unexpected call\n");
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI InPlaceSite_OnInPlaceActivateEx(IOleInPlaceSiteEx *iface,
 470                                                       BOOL *pNoRedraw, DWORD dwFlags)
 471 {
 472     ok(0, "unexpected call\n");
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivateEx(IOleInPlaceSiteEx *iface,
 477                                                         BOOL fNoRedraw)
 478 {
 479     ok(0, "unexpected call\n");
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI InPlaceSite_RequestUIActivate(IOleInPlaceSiteEx *iface)
 484 {
 485     ok(0, "unexpected call\n");
 486     return S_OK;
 487 }
 488
 489 static const IOleInPlaceSiteExVtbl InPlaceSiteExVtbl = {
 490     InPlaceSite_QueryInterface,
 491     InPlaceSite_AddRef,
 492     InPlaceSite_Release,
 493     InPlaceSite_GetWindow,
 494     InPlaceSite_ContextSensitiveHelp,
 495     InPlaceSite_CanInPlaceActivate,
 496     InPlaceSite_OnInPlaceActivate,
 497     InPlaceSite_OnUIActivate,
 498     InPlaceSite_GetWindowContext,
 499     InPlaceSite_Scroll,
 500     InPlaceSite_OnUIDeactivate,
 501     InPlaceSite_OnInPlaceDeactivate,
 502     InPlaceSite_DiscardUndoState,
 503     InPlaceSite_DeactivateAndUndo,
 504     InPlaceSite_OnPosRectChange,
 505     InPlaceSite_OnInPlaceActivateEx,
 506     InPlaceSite_OnInPlaceDeactivateEx,
 507     InPlaceSite_RequestUIActivate
 508 };
 509
 510 static IOleInPlaceSiteEx InPlaceSite = { &InPlaceSiteExVtbl };
 511
 512 static HRESULT QueryInterface(REFIID riid, void **ppv)
 513 {
 514     *ppv = NULL;
 515
 516     if(IsEqualGUID(&IID_IUnknown, riid)
 517             || IsEqualGUID(&IID_IOleClientSite, riid))
 518         *ppv = &ClientSite;
 519     else if(IsEqualGUID(&IID_IOleWindow, riid)
 520             || IsEqualGUID(&IID_IOleInPlaceSite, riid)
 521             || IsEqualGUID(&IID_IOleInPlaceSiteEx, riid))
 522         *ppv = &InPlaceSite;
 523
 524     if(*ppv)
 525         return S_OK;
 526
 527     return E_NOINTERFACE;
 528 }
 529
 530 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 531 {
 532     return DefWindowProcW(hwnd, msg, wParam, lParam);
 533 }
 534
 535 static HWND create_container_window(void)
 536 {
 537     static const WCHAR wszWebBrowserContainer[] =
 538         {'W','e','b','B','r','o','w','s','e','r','C','o','n','t','a','i','n','e','r',0};
 539     static WNDCLASSEXW wndclass = {
 540         sizeof(WNDCLASSEXW),
 541         0,
 542         wnd_proc,
 543         0, 0, NULL, NULL, NULL, NULL, NULL,
 544         wszWebBrowserContainer,
 545         NULL
 546     };
 547
 548     RegisterClassExW(&wndclass);
 549     return CreateWindowW(wszWebBrowserContainer, wszWebBrowserContainer,
 550             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 551             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
 552 }
 553
 554 static void test_DoVerb(IUnknown *unk)
 555 {
 556     IOleObject *oleobj;
 557     RECT rect = {0,0,1000,1000};
 558     HRESULT hres;
 559
 560     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
 561     ok(hres == S_OK, "QueryInterface(IID_OleObject) failed: %08lx\n", hres);
 562     if(FAILED(hres))
 563         return;
 564
 565     SET_EXPECT(CanInPlaceActivate);
 566     SET_EXPECT(Site_GetWindow);
 567     SET_EXPECT(OnInPlaceActivate);
 568     SET_EXPECT(GetWindowContext);
 569     SET_EXPECT(ShowObject);
 570     SET_EXPECT(GetContainer);
 571     SET_EXPECT(Frame_GetWindow);
 572     SET_EXPECT(OnUIActivate);
 573     SET_EXPECT(Frame_SetActiveObject);
 574     SET_EXPECT(UIWindow_SetActiveObject);
 575     SET_EXPECT(SetMenu);
 576
 577     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite,
 578                              0, container_hwnd, &rect);
 579     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
 580
 581     CHECK_CALLED(CanInPlaceActivate);
 582     CHECK_CALLED(Site_GetWindow);
 583     CHECK_CALLED(OnInPlaceActivate);
 584     CHECK_CALLED(GetWindowContext);
 585     CHECK_CALLED(ShowObject);
 586     CHECK_CALLED(GetContainer);
 587     CHECK_CALLED(Frame_GetWindow);
 588     CHECK_CALLED(OnUIActivate);
 589     CHECK_CALLED(Frame_SetActiveObject);
 590     CHECK_CALLED(UIWindow_SetActiveObject);
 591     CHECK_CALLED(SetMenu);
 592
 593     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite,
 594                            0, container_hwnd, &rect);
 595     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
 596
 597     IOleObject_Release(oleobj);
 598 }
 599
 600 static void test_GetMiscStatus(IOleObject *oleobj)
 601 {
 602     DWORD st, i;
 603     HRESULT hres;
 604
 605     for(i=0; i<10; i++) {
 606         st = 0xdeadbeef;
 607         hres = IOleObject_GetMiscStatus(oleobj, i, &st);
 608         ok(hres == S_OK, "GetMiscStatus failed: %08lx\n", hres);
 609         ok(st == (OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 610                   |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE),
 611            "st=%08lx, expected OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|"
 612            "OLEMISC_INSIDEOUT|OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE)\n", st);
 613     }
 614 }
 615
 616 static void test_ClientSite(IUnknown *unk, IOleClientSite *client)
 617 {
 618     IOleObject *oleobj;
 619     IOleInPlaceObject *inplace;
 620     HWND hwnd;
 621     HRESULT hres;
 622
 623     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
 624     ok(hres == S_OK, "QueryInterface(IID_OleObject) failed: %08lx\n", hres);
 625     if(FAILED(hres))
 626         return;
 627
 628     test_GetMiscStatus(oleobj);
 629
 630     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObject, (void**)&inplace);
 631     ok(hres == S_OK, "QueryInterface(IID_OleInPlaceObject) failed: %08lx\n", hres);
 632     if(FAILED(hres)) {
 633         IOleObject_Release(oleobj);
 634         return;
 635     }
 636
 637     hres = IOleInPlaceObject_GetWindow(inplace, &hwnd);
 638     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 639     ok((hwnd == NULL) ^ (client == NULL), "unexpected hwnd %p\n", hwnd);
 640
 641     if(client) {
 642         SET_EXPECT(GetContainer);
 643         SET_EXPECT(Site_GetWindow);
 644     }
 645
 646     hres = IOleObject_SetClientSite(oleobj, client);
 647     ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
 648
 649     if(client) {
 650         CHECK_CALLED(GetContainer);
 651         CHECK_CALLED(Site_GetWindow);
 652     }
 653
 654     hres = IOleInPlaceObject_GetWindow(inplace, &hwnd);
 655     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 656     ok((hwnd == NULL) == (client == NULL), "unexpected hwnd %p\n", hwnd);
 657
 658     shell_embedding_hwnd = hwnd;
 659
 660     IOleInPlaceObject_Release(inplace);
 661     IOleObject_Release(oleobj);
 662 }
 663
 664 static void test_ClassInfo(IUnknown *unk)
 665 {
 666     IProvideClassInfo2 *class_info;
 667     GUID guid;
 668     HRESULT hres;
 669
 670     hres = IUnknown_QueryInterface(unk, &IID_IProvideClassInfo2, (void**)&class_info);
 671     ok(hres == S_OK, "QueryInterface(IID_IProvideClassInfo)  failed: %08lx\n", hres);
 672     if(FAILED(hres))
 673         return;
 674
 675     hres = IProvideClassInfo2_GetGUID(class_info, GUIDKIND_DEFAULT_SOURCE_DISP_IID, &guid);
 676     ok(hres == S_OK, "GetGUID failed: %08lx\n", hres);
 677     ok(IsEqualGUID(&DIID_DWebBrowserEvents2, &guid), "wrong guid\n");
 678
 679     hres = IProvideClassInfo2_GetGUID(class_info, 0, &guid);
 680     ok(hres == E_FAIL, "GetGUID failed: %08lx, expected E_FAIL\n", hres);
 681     ok(IsEqualGUID(&IID_NULL, &guid), "wrong guid\n");
 682
 683     hres = IProvideClassInfo2_GetGUID(class_info, 2, &guid);
 684     ok(hres == E_FAIL, "GetGUID failed: %08lx, expected E_FAIL\n", hres);
 685     ok(IsEqualGUID(&IID_NULL, &guid), "wrong guid\n");
 686
 687     hres = IProvideClassInfo2_GetGUID(class_info, GUIDKIND_DEFAULT_SOURCE_DISP_IID, NULL);
 688     ok(hres == E_POINTER, "GetGUID failed: %08lx, expected E_POINTER\n", hres);
 689
 690     hres = IProvideClassInfo2_GetGUID(class_info, 0, NULL);
 691     ok(hres == E_POINTER, "GetGUID failed: %08lx, expected E_POINTER\n", hres);
 692
 693     IProvideClassInfo2_Release(class_info);
 694 }
 695
 696 static void test_WebBrowser(void)
 697 {
 698     IUnknown *unk = NULL;
 699     ULONG ref;
 700     HRESULT hres;
 701
 702     hres = CoCreateInstance(&CLSID_WebBrowser, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 703             &IID_IUnknown, (void**)&unk);
 704     ok(hres == S_OK, "CoCreateInterface failed: %08lx\n", hres);
 705     if(FAILED(hres))
 706         return;
 707
 708     test_ClassInfo(unk);
 709     test_ClientSite(unk, &ClientSite);
 710     test_DoVerb(unk);
 711     test_ClientSite(unk, NULL);
 712
 713     ref = IUnknown_Release(unk);
 714     ok(ref == 0, "ref=%ld, expected 0\n", ref);
 715 }
 716
 717 START_TEST(webbrowser)
 718 {
 719     container_hwnd = create_container_window();
 720
 721     OleInitialize(NULL);
 722
 723     test_WebBrowser();
 724
 725     OleUninitialize();
 726 }