dlls/wmp/tests/oleobj.c

   1 /*
   2  * Copyright 2014 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 WIN32_LEAN_AND_MEAN
  20 #define COBJMACROS
  21 #include <initguid.h>
  22 #include <windows.h>
  23 #include <wmp.h>
  24 #include <olectl.h>
  25
  26 #include "wine/test.h"
  27
  28 #define DEFINE_EXPECT(func) \
  29     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  30
  31 #define SET_EXPECT(func) \
  32     expect_ ## func = TRUE
  33
  34 #define CHECK_EXPECT2(func) \
  35     do { \
  36         ok(expect_ ##func, "unexpected call " #func "\n"); \
  37         called_ ## func = TRUE; \
  38     }while(0)
  39
  40 #define CHECK_EXPECT(func) \
  41     do { \
  42         CHECK_EXPECT2(func); \
  43         expect_ ## func = FALSE; \
  44     }while(0)
  45
  46 #define CHECK_CALLED(func) \
  47     do { \
  48         ok(called_ ## func, "expected " #func "\n"); \
  49         expect_ ## func = called_ ## func = FALSE; \
  50     }while(0)
  51
  52 DEFINE_EXPECT(GetContainer);
  53 DEFINE_EXPECT(GetExtendedControl);
  54 DEFINE_EXPECT(GetWindow);
  55 DEFINE_EXPECT(Invoke_USERMODE);
  56 DEFINE_EXPECT(CanWindowlessActivate);
  57 DEFINE_EXPECT(OnInPlaceActivateEx);
  58 DEFINE_EXPECT(OnInPlaceDeactivate);
  59 DEFINE_EXPECT(GetWindowContext);
  60 DEFINE_EXPECT(ShowObject);
  61 DEFINE_EXPECT(OnShowWindow_FALSE);
  62
  63 static HWND container_hwnd;
  64
  65 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
  66 {
  67     if(IsEqualGUID(riid, &IID_IUnknown)) {
  68         *ppv = iface;
  69     }else if(IsEqualGUID(riid, &IID_IOleContainer)) {
  70         *ppv = iface;
  71     }else {
  72         trace("OleContainer QI(%s)\n", wine_dbgstr_guid(riid));
  73         *ppv = NULL;
  74         return E_NOINTERFACE;
  75     }
  76
  77     return S_OK;
  78 }
  79
  80 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
  81 {
  82     return 2;
  83 }
  84
  85 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
  86 {
  87     return 1;
  88 }
  89
  90 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc,
  91         LPOLESTR pszDiaplayName, ULONG *pchEaten, IMoniker **ppmkOut)
  92 {
  93     ok(0, "unexpected call\n");
  94     return E_NOTIMPL;
  95 }
  96
  97 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags,
  98         IEnumUnknown **ppenum)
  99 {
 100     ok(0, "unexpected call\n");
 101     return E_NOTIMPL;
 102 }
 103
 104 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
 105 {
 106     ok(0, "unexpected call\n");
 107     return E_NOTIMPL;
 108 }
 109
 110 static const IOleContainerVtbl OleContainerVtbl = {
 111     OleContainer_QueryInterface,
 112     OleContainer_AddRef,
 113     OleContainer_Release,
 114     OleContainer_ParseDisplayName,
 115     OleContainer_EnumObjects,
 116     OleContainer_LockContainer
 117 };
 118
 119 static IOleContainer OleContainer = { &OleContainerVtbl };
 120
 121 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 122 {
 123     ok(0, "Unexpected QI(%s)\n", wine_dbgstr_guid(riid));
 124     *ppv = NULL;
 125     return E_NOINTERFACE;
 126 }
 127
 128 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 129 {
 130     return 2;
 131 }
 132
 133 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
 134 {
 135     return 1;
 136 }
 137
 138 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 139 {
 140     ok(0, "unexpected call\n");
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 145 {
 146     ok(0, "unexpected call\n");
 147     return E_NOTIMPL;
 148 }
 149
 150 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 151 {
 152     ok(0, "unexpected call\n");
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
 157         LPCBORDERWIDTHS pborderwidths)
 158 {
 159     ok(0, "unexpected call\n");
 160     return E_NOTIMPL;
 161 }
 162
 163 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
 164         LPCBORDERWIDTHS pborderwidths)
 165 {
 166     ok(0, "unexpected call\n");
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
 171         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 172 {
 173     ok(0, "unexpected call\n");
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 178         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 179 {
 180     ok(0, "unexpected call\n");
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 185         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 186 {
 187     ok(0, "unexpected call\n");
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 192         HOLEMENU holemenu, HWND hwndActiveObject)
 193 {
 194     ok(0, "unexpected call\n");
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 199 {
 200     ok(0, "unexpected call\n");
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 205 {
 206     ok(0, "unexpected call\n");
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 211 {
 212     ok(0, "unexpected call\n");
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 217 {
 218     ok(0, "unexpected call\n");
 219     return E_NOTIMPL;
 220 }
 221
 222 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 223     InPlaceFrame_QueryInterface,
 224     InPlaceFrame_AddRef,
 225     InPlaceFrame_Release,
 226     InPlaceFrame_GetWindow,
 227     InPlaceFrame_ContextSensitiveHelp,
 228     InPlaceFrame_GetBorder,
 229     InPlaceFrame_RequestBorderSpace,
 230     InPlaceFrame_SetBorderSpace,
 231     InPlaceFrame_SetActiveObject,
 232     InPlaceFrame_InsertMenus,
 233     InPlaceFrame_SetMenu,
 234     InPlaceFrame_RemoveMenus,
 235     InPlaceFrame_SetStatusText,
 236     InPlaceFrame_EnableModeless,
 237     InPlaceFrame_TranslateAccelerator
 238 };
 239
 240 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 241
 242 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
 243     InPlaceFrame_QueryInterface,
 244     InPlaceFrame_AddRef,
 245     InPlaceFrame_Release,
 246     InPlaceFrame_GetWindow,
 247     InPlaceFrame_ContextSensitiveHelp,
 248     InPlaceFrame_GetBorder,
 249     InPlaceFrame_RequestBorderSpace,
 250     InPlaceFrame_SetBorderSpace,
 251     InPlaceUIWindow_SetActiveObject,
 252 };
 253
 254 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
 255
 256 static HRESULT cs_qi(REFIID,void**);
 257
 258 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 259 {
 260     return cs_qi(riid, ppv);
 261 }
 262
 263 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
 264 {
 265     return 2;
 266 }
 267
 268 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
 269 {
 270     return 1;
 271 }
 272
 273 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
 274 {
 275     ok(0, "unexpected call\n");
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
 280         IMoniker **ppmon)
 281 {
 282     ok(0, "unexpected call\n");
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 287 {
 288     CHECK_EXPECT2(GetContainer);
 289
 290     *ppContainer = &OleContainer;
 291     return S_OK;
 292 }
 293
 294 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
 295 {
 296     CHECK_EXPECT(ShowObject);
 297     return S_OK;
 298 }
 299
 300 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 301 {
 302     if(fShow)
 303         ok(0, "unexpected call\n");
 304     else
 305         CHECK_EXPECT(OnShowWindow_FALSE);
 306     return S_OK;
 307 }
 308
 309 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 310 {
 311     ok(0, "unexpected call\n");
 312     return E_NOTIMPL;
 313 }
 314
 315 static const IOleClientSiteVtbl ClientSiteVtbl = {
 316     ClientSite_QueryInterface,
 317     ClientSite_AddRef,
 318     ClientSite_Release,
 319     ClientSite_SaveObject,
 320     ClientSite_GetMoniker,
 321     ClientSite_GetContainer,
 322     ClientSite_ShowObject,
 323     ClientSite_OnShowWindow,
 324     ClientSite_RequestNewObjectLayout
 325 };
 326
 327 static IOleClientSite ClientSite = { &ClientSiteVtbl };
 328
 329 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
 330                                                      REFIID riid, void **ppv)
 331 {
 332     return cs_qi(riid, ppv);
 333 }
 334
 335 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 336 {
 337     return 2;
 338 }
 339
 340 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 341 {
 342     return 1;
 343 }
 344
 345 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
 346                                     REFIID riid, void **ppv)
 347 {
 348     trace("QS(%s)\n", wine_dbgstr_guid(guidService));
 349     *ppv = NULL;
 350     return E_NOINTERFACE;
 351 }
 352
 353 static const IServiceProviderVtbl ServiceProviderVtbl = {
 354     ServiceProvider_QueryInterface,
 355     ServiceProvider_AddRef,
 356     ServiceProvider_Release,
 357     ServiceProvider_QueryService
 358 };
 359
 360 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
 361
 362 static HRESULT WINAPI OleControlSite_QueryInterface(IOleControlSite *iface, REFIID riid, void **ppv)
 363 {
 364     return cs_qi(riid, ppv);
 365 }
 366
 367 static ULONG WINAPI OleControlSite_AddRef(IOleControlSite *iface)
 368 {
 369     return 2;
 370 }
 371
 372 static ULONG WINAPI OleControlSite_Release(IOleControlSite *iface)
 373 {
 374     return 1;
 375 }
 376
 377 static HRESULT WINAPI OleControlSite_OnControlInfoChanged(IOleControlSite *iface)
 378 {
 379     ok(0, "unexpected call\n");
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI OleControlSite_LockInPlaceActive(IOleControlSite *iface, BOOL fLock)
 384 {
 385     ok(0, "unexpected call\n");
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI OleControlSite_GetExtendedControl(IOleControlSite *iface, IDispatch **ppDisp)
 390 {
 391     CHECK_EXPECT(GetExtendedControl);
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI OleControlSite_TransformCoords(IOleControlSite *iface, POINTL *pPtHimetric,
 396         POINTF *pPtfContainer, DWORD dwFlags)
 397 {
 398     ok(0, "unexpected call\n");
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI OleControlSite_TranslateAccelerator(IOleControlSite *iface,
 403         MSG *pMsg, DWORD grfModifiers)
 404 {
 405     ok(0, "unexpected call\n");
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI OleControlSite_OnFocus(IOleControlSite *iface, BOOL fGotFocus)
 410 {
 411     ok(0, "unexpected call\n");
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI OleControlSite_ShowPropertyFrame(IOleControlSite *iface)
 416 {
 417     ok(0, "unexpected call\n");
 418     return E_NOTIMPL;
 419 }
 420
 421 static const IOleControlSiteVtbl OleControlSiteVtbl = {
 422     OleControlSite_QueryInterface,
 423     OleControlSite_AddRef,
 424     OleControlSite_Release,
 425     OleControlSite_OnControlInfoChanged,
 426     OleControlSite_LockInPlaceActive,
 427     OleControlSite_GetExtendedControl,
 428     OleControlSite_TransformCoords,
 429     OleControlSite_TranslateAccelerator,
 430     OleControlSite_OnFocus,
 431     OleControlSite_ShowPropertyFrame
 432 };
 433
 434 static IOleControlSite OleControlSite = { &OleControlSiteVtbl };
 435
 436 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 437 {
 438     return cs_qi(riid, ppv);
 439 }
 440
 441 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 442 {
 443     return 2;
 444 }
 445
 446 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 447 {
 448     return 1;
 449 }
 450
 451 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 452 {
 453     ok(0, "unexpected call\n");
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 458         ITypeInfo **ppTInfo)
 459 {
 460     ok(0, "unexpected call\n");
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 465         UINT cNames, LCID lcid, DISPID *rgDispId)
 466 {
 467     ok(0, "unexpected call\n");
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 472         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 473         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 474 {
 475     switch(dispIdMember) {
 476     case DISPID_AMBIENT_USERMODE:
 477         CHECK_EXPECT(Invoke_USERMODE);
 478         break;
 479     default:
 480         ok(0, "unexpected call Invoke(%d)\n", dispIdMember);
 481     }
 482
 483     return E_NOTIMPL;
 484 }
 485
 486 static const IDispatchVtbl DispatchVtbl = {
 487     Dispatch_QueryInterface,
 488     Dispatch_AddRef,
 489     Dispatch_Release,
 490     Dispatch_GetTypeInfoCount,
 491     Dispatch_GetTypeInfo,
 492     Dispatch_GetIDsOfNames,
 493     Dispatch_Invoke
 494 };
 495
 496 static IDispatch Dispatch = { &DispatchVtbl };
 497
 498 static HRESULT WINAPI InPlaceSiteWindowless_QueryInterface(IOleInPlaceSiteWindowless *iface, REFIID riid, void **ppv)
 499 {
 500     return cs_qi(riid, ppv);
 501 }
 502
 503 static ULONG WINAPI InPlaceSiteWindowless_AddRef(IOleInPlaceSiteWindowless *iface)
 504 {
 505     return 2;
 506 }
 507
 508 static ULONG WINAPI InPlaceSiteWindowless_Release(IOleInPlaceSiteWindowless *iface)
 509 {
 510     return 1;
 511 }
 512
 513 static HRESULT WINAPI InPlaceSiteWindowless_GetWindow(IOleInPlaceSiteWindowless *iface, HWND *phwnd)
 514 {
 515     CHECK_EXPECT2(GetWindow);
 516     *phwnd = container_hwnd;
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI InPlaceSiteWindowless_ContextSensitiveHelp(IOleInPlaceSiteWindowless *iface, BOOL fEnterMode)
 521 {
 522     ok(0, "unexpected call\n");
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI InPlaceSiteWindowless_CanInPlaceActivate(IOleInPlaceSiteWindowless *iface)
 527 {
 528     ok(0, "unexpected call\n");
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceActivate(IOleInPlaceSiteWindowless *iface)
 533 {
 534     ok(0, "unexpected call\n");
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI InPlaceSiteWindowless_OnUIActivate(IOleInPlaceSiteWindowless *iface)
 539 {
 540     ok(0, "unexpected call\n");
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI InPlaceSiteWindowless_GetWindowContext(IOleInPlaceSiteWindowless *iface, IOleInPlaceFrame **ppFrame,
 545         IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 546 {
 547     static const RECT rect = {0,0,400,410};
 548
 549     CHECK_EXPECT(GetWindowContext);
 550
 551     ok(ppFrame != NULL, "ppFrame = NULL\n");
 552     if(ppFrame)
 553         *ppFrame = &InPlaceFrame;
 554     ok(ppDoc != NULL, "ppDoc = NULL\n");
 555     if(ppDoc)
 556         *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
 557     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
 558     if(lprcPosRect)
 559         memcpy(lprcPosRect, &rect, sizeof(RECT));
 560     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
 561     if(lprcClipRect)
 562         memcpy(lprcClipRect, &rect, sizeof(RECT));
 563     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
 564     if(lpFrameInfo) {
 565         ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
 566         lpFrameInfo->fMDIApp = FALSE;
 567         lpFrameInfo->hwndFrame = container_hwnd;
 568         lpFrameInfo->haccel = NULL;
 569         lpFrameInfo->cAccelEntries = 0;
 570     }
 571
 572     return S_OK;
 573 }
 574
 575 static HRESULT WINAPI InPlaceSiteWindowless_Scroll(
 576         IOleInPlaceSiteWindowless *iface, SIZE scrollExtent)
 577 {
 578     ok(0, "unexpected call\n");
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI InPlaceSiteWindowless_OnUIDeactivate(
 583         IOleInPlaceSiteWindowless *iface, BOOL fUndoable)
 584 {
 585     ok(0, "unexpected call\n");
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceDeactivate(
 590         IOleInPlaceSiteWindowless *iface)
 591 {
 592     CHECK_EXPECT(OnInPlaceDeactivate);
 593     return S_OK;
 594 }
 595
 596 static HRESULT WINAPI InPlaceSiteWindowless_DiscardUndoState(
 597         IOleInPlaceSiteWindowless *iface)
 598 {
 599     ok(0, "unexpected call\n");
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI InPlaceSiteWindowless_DeactivateAndUndo(
 604         IOleInPlaceSiteWindowless *iface)
 605 {
 606     ok(0, "unexpected call\n");
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI InPlaceSiteWindowless_OnPosRectChange(
 611         IOleInPlaceSiteWindowless *iface, LPCRECT lprcPosRect)
 612 {
 613     ok(0, "unexpected call\n");
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceActivateEx(
 618         IOleInPlaceSiteWindowless *iface, BOOL *pfNoRedraw, DWORD dwFlags)
 619 {
 620     CHECK_EXPECT(OnInPlaceActivateEx);
 621     ok(!dwFlags, "dwFlags = %x\n", dwFlags);
 622     ok(pfNoRedraw != NULL, "pfNoRedraw = NULL\n");
 623     return S_OK;
 624 }
 625
 626 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceDeactivateEx(
 627         IOleInPlaceSiteWindowless *iface, BOOL fNoRedraw)
 628 {
 629     ok(0, "unexpected call\n");
 630     return E_NOTIMPL;
 631 }
 632
 633 static HRESULT WINAPI InPlaceSiteWindowless_RequestUIActivate(
 634         IOleInPlaceSiteWindowless *iface)
 635 {
 636     ok(0, "unexpected call\n");
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI InPlaceSiteWindowless_CanWindowlessActivate(
 641         IOleInPlaceSiteWindowless *iface)
 642 {
 643     CHECK_EXPECT(CanWindowlessActivate);
 644     return S_FALSE;
 645 }
 646
 647 static HRESULT WINAPI InPlaceSiteWindowless_GetCapture(
 648         IOleInPlaceSiteWindowless *iface)
 649 {
 650     ok(0, "unexpected call\n");
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT WINAPI InPlaceSiteWindowless_SetCapture(
 655         IOleInPlaceSiteWindowless *iface, BOOL fCapture)
 656 {
 657     ok(0, "unexpected call\n");
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI InPlaceSiteWindowless_GetFocus(
 662         IOleInPlaceSiteWindowless *iface)
 663 {
 664     ok(0, "unexpected call\n");
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI InPlaceSiteWindowless_SetFocus(
 669         IOleInPlaceSiteWindowless *iface, BOOL fFocus)
 670 {
 671     ok(0, "unexpected call\n");
 672     return E_NOTIMPL;
 673 }
 674
 675 static HRESULT WINAPI InPlaceSiteWindowless_GetDC(
 676         IOleInPlaceSiteWindowless *iface, LPCRECT pRect,
 677         DWORD grfFlags, HDC *phDC)
 678 {
 679     ok(0, "unexpected call\n");
 680     return E_NOTIMPL;
 681 }
 682
 683 static HRESULT WINAPI InPlaceSiteWindowless_ReleaseDC(
 684         IOleInPlaceSiteWindowless *iface, HDC hDC)
 685 {
 686     ok(0, "unexpected call\n");
 687     return E_NOTIMPL;
 688 }
 689
 690 static HRESULT WINAPI InPlaceSiteWindowless_InvalidateRect(
 691         IOleInPlaceSiteWindowless *iface, LPCRECT pRect, BOOL fErase)
 692 {
 693     ok(0, "unexpected call\n");
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI InPlaceSiteWindowless_InvalidateRgn(
 698         IOleInPlaceSiteWindowless *iface, HRGN hRGN, BOOL fErase)
 699 {
 700     ok(0, "unexpected call\n");
 701     return E_NOTIMPL;
 702 }
 703
 704 static HRESULT WINAPI InPlaceSiteWindowless_ScrollRect(
 705         IOleInPlaceSiteWindowless *iface, INT dx, INT dy,
 706         LPCRECT pRectScroll, LPCRECT pRectClip)
 707 {
 708     ok(0, "unexpected call\n");
 709     return E_NOTIMPL;
 710 }
 711
 712 static HRESULT WINAPI InPlaceSiteWindowless_AdjustRect(
 713         IOleInPlaceSiteWindowless *iface, LPRECT prc)
 714 {
 715     ok(0, "unexpected call\n");
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI InPlaceSiteWindowless_OnDefWindowMessage(
 720         IOleInPlaceSiteWindowless *iface, UINT msg,
 721         WPARAM wParam, LPARAM lParam, LRESULT *plResult)
 722 {
 723     ok(0, "unexpected call\n");
 724     return E_NOTIMPL;
 725 }
 726
 727 static const IOleInPlaceSiteWindowlessVtbl InPlaceSiteWindowlessVtbl = {
 728     InPlaceSiteWindowless_QueryInterface,
 729     InPlaceSiteWindowless_AddRef,
 730     InPlaceSiteWindowless_Release,
 731     InPlaceSiteWindowless_GetWindow,
 732     InPlaceSiteWindowless_ContextSensitiveHelp,
 733     InPlaceSiteWindowless_CanInPlaceActivate,
 734     InPlaceSiteWindowless_OnInPlaceActivate,
 735     InPlaceSiteWindowless_OnUIActivate,
 736     InPlaceSiteWindowless_GetWindowContext,
 737     InPlaceSiteWindowless_Scroll,
 738     InPlaceSiteWindowless_OnUIDeactivate,
 739     InPlaceSiteWindowless_OnInPlaceDeactivate,
 740     InPlaceSiteWindowless_DiscardUndoState,
 741     InPlaceSiteWindowless_DeactivateAndUndo,
 742     InPlaceSiteWindowless_OnPosRectChange,
 743     InPlaceSiteWindowless_OnInPlaceActivateEx,
 744     InPlaceSiteWindowless_OnInPlaceDeactivateEx,
 745     InPlaceSiteWindowless_RequestUIActivate,
 746     InPlaceSiteWindowless_CanWindowlessActivate,
 747     InPlaceSiteWindowless_GetCapture,
 748     InPlaceSiteWindowless_SetCapture,
 749     InPlaceSiteWindowless_GetFocus,
 750     InPlaceSiteWindowless_SetFocus,
 751     InPlaceSiteWindowless_GetDC,
 752     InPlaceSiteWindowless_ReleaseDC,
 753     InPlaceSiteWindowless_InvalidateRect,
 754     InPlaceSiteWindowless_InvalidateRgn,
 755     InPlaceSiteWindowless_ScrollRect,
 756     InPlaceSiteWindowless_AdjustRect,
 757     InPlaceSiteWindowless_OnDefWindowMessage
 758 };
 759
 760 static IOleInPlaceSiteWindowless InPlaceSiteWindowless = { &InPlaceSiteWindowlessVtbl };
 761
 762 static HRESULT cs_qi(REFIID riid, void **ppv)
 763 {
 764     if(IsEqualGUID(riid, &IID_IUnknown)) {
 765         *ppv = &ClientSite;
 766     }else if(IsEqualGUID(riid, &IID_IOleClientSite)) {
 767         *ppv = &ClientSite;
 768     }else if(IsEqualGUID(riid, &IID_IServiceProvider)) {
 769         *ppv = &ServiceProvider;
 770     }else if(IsEqualGUID(riid, &IID_IOleControlSite)) {
 771         *ppv = &OleControlSite;
 772     }else if(IsEqualGUID(riid, &IID_IDispatch)) {
 773         *ppv = &Dispatch;
 774     }else if(IsEqualGUID(&IID_IOleWindow, riid)) {
 775         *ppv = &InPlaceSiteWindowless;
 776     }else if(IsEqualGUID(&IID_IOleInPlaceSite, riid)) {
 777         *ppv = &InPlaceSiteWindowless;
 778     }else if(IsEqualGUID(&IID_IOleInPlaceSiteEx, riid)) {
 779         *ppv = &InPlaceSiteWindowless;
 780     }else if(IsEqualGUID(&IID_IOleInPlaceSiteWindowless, riid)) {
 781         *ppv = &InPlaceSiteWindowless;
 782     }else {
 783         trace("QI(%s)\n", wine_dbgstr_guid(riid));
 784         *ppv = NULL;
 785         return E_NOINTERFACE;
 786     }
 787
 788     return S_OK;
 789 }
 790
 791 static void test_wmp_ifaces(IOleObject *oleobj)
 792 {
 793     IWMPSettings *settings, *settings_qi;
 794     IWMPPlayer4 *player4;
 795     HRESULT hres;
 796
 797     hres = IOleObject_QueryInterface(oleobj, &IID_IWMPPlayer4, (void**)&player4);
 798     ok(hres == S_OK, "Could not get IWMPPlayer4 iface: %08x\n", hres);
 799
 800     settings = NULL;
 801     hres = IWMPPlayer4_get_settings(player4, &settings);
 802     ok(hres == S_OK, "get_settings failed: %08x\n", hres);
 803     ok(settings != NULL, "settings = NULL\n");
 804
 805     hres = IOleObject_QueryInterface(oleobj, &IID_IWMPSettings, (void**)&settings_qi);
 806     ok(hres == S_OK, "Could not get IWMPSettings iface: %08x\n", hres);
 807     ok(settings == settings_qi, "settings != settings_qi\n");
 808     IWMPSettings_Release(settings_qi);
 809
 810     IWMPSettings_Release(settings);
 811     IWMPPlayer4_Release(player4);
 812 }
 813
 814 #define test_rect_size(a,b,c) _test_rect_size(__LINE__,a,b,c)
 815 static void _test_rect_size(unsigned line, const RECT *r, int width, int height)
 816 {
 817     ok_(__FILE__,line)(r->right-r->left == width, "width = %d, expected %d\n", r->right-r->left, width);
 818     ok_(__FILE__,line)(r->bottom-r->top == height, "height = %d, expected %d\n", r->bottom-r->top, height);
 819 }
 820
 821 static void test_window(HWND hwnd)
 822 {
 823     WINDOWINFO wi = {sizeof(wi)};
 824     char class_name[100];
 825     int i;
 826     BOOL res;
 827
 828     i = RealGetWindowClassA(hwnd, class_name, sizeof(class_name));
 829     ok(!strncmp(class_name, "ATL:", 4), "class_name = %s %d\n", class_name, i);
 830
 831     res = GetWindowInfo(hwnd, &wi);
 832     ok(res, "GetWindowInfo failed: %u\n", GetLastError());
 833
 834     test_rect_size(&wi.rcWindow, 400, 410);
 835     test_rect_size(&wi.rcClient, 400, 410);
 836
 837     ok(wi.dwStyle == (WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_VISIBLE|WS_CHILD), "dwStyle = %x\n", wi.dwStyle);
 838     ok(!(wi.dwExStyle & ~0x800 /* undocumented, set by some versions */), "dwExStyle = %x\n", wi.dwExStyle);
 839
 840     ok(IsWindowVisible(hwnd), "Window is not visible\n");
 841 }
 842
 843 static void test_QI(IUnknown *unk)
 844 {
 845     IUnknown *tmp;
 846     HRESULT hres;
 847
 848     hres = IUnknown_QueryInterface(unk, &IID_IQuickActivate, (void**)&tmp);
 849     ok(hres == E_NOINTERFACE, "Got IQuickActivate iface when no expected\n");
 850
 851     hres = IUnknown_QueryInterface(unk, &IID_IMarshal, (void**)&tmp);
 852     ok(hres == E_NOINTERFACE, "Could not get IMarshal iface: %08x\n", hres);
 853
 854     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless, (void**)&tmp);
 855     ok(hres == S_OK, "Could not get IOleInPlaceObjectWindowless iface: %08x\n", hres);
 856     IUnknown_Release(tmp);
 857 }
 858
 859 static void test_IConnectionPointContainer(IOleObject *oleobj)
 860 {
 861     IConnectionPointContainer *container;
 862     IConnectionPoint *point;
 863     HRESULT hres;
 864
 865     hres = IOleObject_QueryInterface(oleobj, &IID_IConnectionPointContainer, (void**)&container);
 866     ok(hres == S_OK, "Could not get IConnectionPointContainer iface: %08x\n", hres);
 867
 868     hres = IConnectionPointContainer_FindConnectionPoint(container, &IID_IPropertyNotifySink, &point);
 869     ok(hres == CONNECT_E_NOCONNECTION, "got: %08x\n", hres);
 870
 871     point = NULL;
 872     hres = IConnectionPointContainer_FindConnectionPoint(container, &IID_IWMPEvents, &point);
 873     todo_wine ok(hres == S_OK, "got: %08x\n", hres);
 874     if(point)
 875         IConnectionPoint_Release(point);
 876
 877     point = NULL;
 878     hres = IConnectionPointContainer_FindConnectionPoint(container, &IID_IWMPEvents2, &point);
 879     todo_wine ok(hres == S_OK, "got: %08x\n", hres);
 880     if(point)
 881         IConnectionPoint_Release(point);
 882
 883     point = NULL;
 884     hres = IConnectionPointContainer_FindConnectionPoint(container, &IID_IWMPEvents3, &point);
 885     if(FAILED(hres))
 886         todo_wine win_skip("IWMPEvents3 not supported\n");
 887     if(point)
 888         IConnectionPoint_Release(point);
 889
 890     point = NULL;
 891     hres = IConnectionPointContainer_FindConnectionPoint(container, &IID_IWMPEvents4, &point);
 892     if(FAILED(hres))
 893         todo_wine win_skip("IWMPEvents4 not supported\n");
 894     if(point)
 895         IConnectionPoint_Release(point);
 896
 897     point = NULL;
 898     hres = IConnectionPointContainer_FindConnectionPoint(container, &IID__WMPOCXEvents, &point);
 899     todo_wine ok(hres == S_OK, "got: %08x\n", hres);
 900     if(point)
 901         IConnectionPoint_Release(point);
 902
 903     IConnectionPointContainer_Release(container);
 904 }
 905
 906 static void test_extent(IOleObject *oleobj)
 907 {
 908     SIZE expected, extent;
 909     DWORD dpi_x;
 910     DWORD dpi_y;
 911     HDC hdc;
 912     HRESULT hres;
 913
 914     /* default aspect ratio is 96dpi / 96dpi */
 915     hdc = GetDC(0);
 916     dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
 917     dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
 918     ReleaseDC(0, hdc);
 919     if (dpi_x != 96 || dpi_y != 96)
 920         trace("dpi: %d / %d\n", dpi_y, dpi_y);
 921
 922     extent.cx = extent.cy = 0xdeadbeef;
 923     hres = IOleObject_GetExtent(oleobj, DVASPECT_CONTENT, &extent);
 924     ok(hres == S_OK, "GetExtent failed: %08x\n", hres);
 925     expected.cx = MulDiv(192, 2540, dpi_x);
 926     expected.cy = MulDiv(192, 2540, dpi_y);
 927     ok(extent.cx == expected.cx && extent.cy == expected.cy, "size = {%d %d} (expected %d %d)\n",
 928        extent.cx, extent.cy, expected.cx, expected.cy );
 929
 930     extent.cx = 800;
 931     extent.cy = 700;
 932     hres = IOleObject_SetExtent(oleobj, DVASPECT_CONTENT, &extent);
 933     ok(hres == S_OK, "SetExtent failed: %08x\n", hres);
 934
 935     extent.cx = extent.cy = 0xdeadbeef;
 936     hres = IOleObject_GetExtent(oleobj, DVASPECT_CONTENT, &extent);
 937     ok(hres == S_OK, "GetExtent failed: %08x\n", hres);
 938     ok(extent.cx == 800 && extent.cy == 700, "size = {%d %d}\n", extent.cx, extent.cy);
 939
 940     hres = IOleObject_GetExtent(oleobj, 0, &extent);
 941     ok(hres == E_FAIL, "GetExtent failed: %08x\n", hres);
 942     hres = IOleObject_GetExtent(oleobj, 7, &extent);
 943     ok(hres == E_FAIL, "GetExtent failed: %08x\n", hres);
 944
 945     extent.cx = 900;
 946     extent.cy = 800;
 947     hres = IOleObject_SetExtent(oleobj, DVASPECT_CONTENT, &expected);
 948     ok(hres == S_OK, "SetExtent failed: %08x\n", hres);
 949
 950     hres = IOleObject_SetExtent(oleobj, 0, &expected);
 951     ok(hres == DV_E_DVASPECT, "SetExtent failed: %08x\n", hres);
 952     hres = IOleObject_SetExtent(oleobj, 7, &expected);
 953     ok(hres == DV_E_DVASPECT, "SetExtent failed: %08x\n", hres);
 954 }
 955
 956 static void test_wmp(void)
 957 {
 958     IProvideClassInfo2 *class_info;
 959     IOleClientSite *client_site;
 960     IOleInPlaceObject *ipobj;
 961     IPersistStreamInit *psi;
 962     IOleObject *oleobj;
 963     IWMPCore *wmpcore;
 964     DWORD misc_status;
 965     RECT pos = {0,0,100,100};
 966     HWND hwnd;
 967     GUID guid;
 968     LONG ref;
 969     HRESULT hres;
 970     BSTR str;
 971
 972     hres = CoCreateInstance(&CLSID_WindowsMediaPlayer, NULL, CLSCTX_INPROC_SERVER, &IID_IOleObject, (void**)&oleobj);
 973     if(hres == REGDB_E_CLASSNOTREG) {
 974         win_skip("CLSID_WindowsMediaPlayer not registered\n");
 975         return;
 976     }
 977     ok(hres == S_OK, "Could not create CLSID_WindowsMediaPlayer instance: %08x\n", hres);
 978
 979     hres = IOleObject_QueryInterface(oleobj, &IID_IWMPCore, (void**)&wmpcore);
 980     ok(hres == S_OK, "got 0x%08x\n", hres);
 981
 982     hres = IWMPCore_get_versionInfo(wmpcore, NULL);
 983     ok(hres == E_POINTER, "got 0x%08x\n", hres);
 984
 985     hres = IWMPCore_get_versionInfo(wmpcore, &str);
 986     ok(hres == S_OK, "got 0x%08x\n", hres);
 987     SysFreeString(str);
 988
 989     IWMPCore_Release(wmpcore);
 990
 991     hres = IOleObject_QueryInterface(oleobj, &IID_IProvideClassInfo2, (void**)&class_info);
 992     ok(hres == S_OK, "Could not get IProvideClassInfo2 iface: %08x\n", hres);
 993
 994     hres = IProvideClassInfo2_GetGUID(class_info, GUIDKIND_DEFAULT_SOURCE_DISP_IID, &guid);
 995     ok(hres == S_OK, "GetGUID failed: %08x\n", hres);
 996     ok(IsEqualGUID(&guid, &IID__WMPOCXEvents), "guid = %s\n", wine_dbgstr_guid(&guid));
 997
 998     IProvideClassInfo2_Release(class_info);
 999
1000     test_QI((IUnknown*)oleobj);
1001     test_IConnectionPointContainer(oleobj);
1002     test_extent(oleobj);
1003
1004     hres = IOleObject_GetMiscStatus(oleobj, DVASPECT_CONTENT, &misc_status);
1005     ok(hres == S_OK, "GetMiscStatus failed: %08x\n", hres);
1006     ok(misc_status == (OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
1007                        |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE), "misc_status = %x\n", misc_status);
1008
1009     hres = IOleObject_QueryInterface(oleobj, &IID_IPersistStreamInit, (void**)&psi);
1010     ok(hres == S_OK, "Could not get IPersistStreamInit iface: %08x\n", hres);
1011
1012     hres = IOleObject_QueryInterface(oleobj, &IID_IOleInPlaceObject, (void**)&ipobj);
1013     ok(hres == S_OK, "Could not get IOleInPlaceObject iface: %08x\n", hres);
1014
1015     hres = IPersistStreamInit_InitNew(psi);
1016     ok(hres == E_FAIL || broken(hres == S_OK /* Old WMP */), "InitNew failed: %08x\n", hres);
1017
1018     SET_EXPECT(GetContainer);
1019     SET_EXPECT(GetExtendedControl);
1020     SET_EXPECT(GetWindow);
1021     SET_EXPECT(Invoke_USERMODE);
1022     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1023     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1024     todo_wine CHECK_CALLED(GetContainer);
1025     CHECK_CALLED(GetExtendedControl);
1026     todo_wine CHECK_CALLED(GetWindow);
1027     todo_wine CHECK_CALLED(Invoke_USERMODE);
1028
1029     client_site = NULL;
1030     hres = IOleObject_GetClientSite(oleobj, &client_site);
1031     ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
1032     ok(client_site == &ClientSite, "client_site != ClientSite\n");
1033
1034     SET_EXPECT(GetWindow);
1035     hres = IPersistStreamInit_InitNew(psi);
1036     ok(hres == S_OK, "InitNew failed: %08x\n", hres);
1037     CHECK_CALLED(GetWindow);
1038
1039     hwnd = (HWND)0xdeadbeef;
1040     hres = IOleInPlaceObject_GetWindow(ipobj, &hwnd);
1041     ok(hres == E_UNEXPECTED, "GetWindow failed: %08x\n", hres);
1042     ok(!hwnd, "hwnd = %p\n", hwnd);
1043
1044     SET_EXPECT(GetWindow);
1045     SET_EXPECT(CanWindowlessActivate);
1046     SET_EXPECT(OnInPlaceActivateEx);
1047     SET_EXPECT(GetWindowContext);
1048     SET_EXPECT(ShowObject);
1049     hres = IOleObject_DoVerb(oleobj, OLEIVERB_INPLACEACTIVATE, NULL, &ClientSite, 0, container_hwnd, &pos);
1050     ok(hres == S_OK, "DoVerb failed: %08x\n", hres);
1051     CHECK_CALLED(GetWindow);
1052     CHECK_CALLED(CanWindowlessActivate);
1053     CHECK_CALLED(OnInPlaceActivateEx);
1054     CHECK_CALLED(GetWindowContext);
1055     CHECK_CALLED(ShowObject);
1056
1057     hwnd = NULL;
1058     hres = IOleInPlaceObject_GetWindow(ipobj, &hwnd);
1059     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1060     ok(hwnd != NULL, "hwnd = NULL\n");
1061
1062     test_window(hwnd);
1063
1064     SetRect(&pos, 1, 2, 301, 312);
1065     hres = IOleInPlaceObject_SetObjectRects(ipobj, &pos, &pos);
1066     ok(hres == S_OK, "SetObjectRects failed: %08x\n", hres);
1067     GetClientRect(hwnd, &pos);
1068     test_rect_size(&pos, 300, 310);
1069
1070     test_wmp_ifaces(oleobj);
1071
1072     hres = IOleObject_DoVerb(oleobj, OLEIVERB_HIDE, NULL, &ClientSite, 0, container_hwnd, &pos);
1073     ok(hres == S_OK, "DoVerb failed: %08x\n", hres);
1074     ok(!IsWindowVisible(hwnd), "Window is visible\n");
1075
1076     SET_EXPECT(OnShowWindow_FALSE);
1077     SET_EXPECT(OnInPlaceDeactivate);
1078     hres = IOleObject_Close(oleobj, 0);
1079     ok(hres == S_OK, "Close failed: %08x\n", hres);
1080     todo_wine CHECK_CALLED(OnShowWindow_FALSE);
1081     CHECK_CALLED(OnInPlaceDeactivate);
1082
1083     hwnd = (HWND)0xdeadbeef;
1084     hres = IOleInPlaceObject_GetWindow(ipobj, &hwnd);
1085     ok(hres == E_UNEXPECTED, "GetWindow failed: %08x\n", hres);
1086     ok(!hwnd, "hwnd = %p\n", hwnd);
1087
1088     hres = IOleObject_Close(oleobj, 0);
1089     ok(hres == S_OK, "Close failed: %08x\n", hres);
1090
1091     hres = IOleObject_SetClientSite(oleobj, NULL);
1092     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1093
1094     client_site = (void*)0xdeadbeef;
1095     hres = IOleObject_GetClientSite(oleobj, &client_site);
1096     ok(hres == E_FAIL || broken(hres == S_OK), "GetClientSite failed: %08x\n", hres);
1097     ok(!client_site, "client_site = %p\n", client_site);
1098
1099     IPersistStreamInit_Release(psi);
1100     IOleInPlaceObject_Release(ipobj);
1101
1102     ref = IOleObject_Release(oleobj);
1103     ok(!ref, "ref = %d\n", ref);
1104 }
1105
1106 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1107 {
1108     return DefWindowProcW(hwnd, msg, wParam, lParam);
1109 }
1110
1111 static void create_container_window(void)
1112 {
1113     static const WCHAR wmp_testW[] =
1114         {'W','M','P','T','e','s','t',0};
1115     static WNDCLASSEXW wndclass = {
1116         sizeof(WNDCLASSEXW),
1117         0,
1118         wnd_proc,
1119         0, 0, NULL, NULL, NULL, NULL, NULL,
1120         wmp_testW,
1121         NULL
1122     };
1123
1124     RegisterClassExW(&wndclass);
1125     container_hwnd = CreateWindowW(wmp_testW, wmp_testW,
1126             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
1127             515, 530, NULL, NULL, NULL, NULL);
1128     ShowWindow(container_hwnd, SW_SHOW);
1129 }
1130
1131 START_TEST(oleobj)
1132 {
1133     create_container_window();
1134     CoInitialize(NULL);
1135
1136     test_wmp();
1137
1138     CoUninitialize();
1139     DestroyWindow(container_hwnd);
1140 }