git.oblomov.eu Git - wine/blob - dlls/ole32/tests/ole2.c

   1 /*
   2  * Object Linking and Embedding Tests
   3  *
   4  * Copyright 2005 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29 #include "shlguid.h"
  30
  31 #include "wine/test.h"
  32
  33 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  34
  35 static IPersistStorage OleObjectPersistStg;
  36 static IOleCache *cache;
  37 static IRunnableObject *runnable;
  38
  39 static const CLSID CLSID_WineTest =
  40 { /* 9474ba1a-258b-490b-bc13-516e9239ace0 */
  41     0x9474ba1a,
  42     0x258b,
  43     0x490b,
  44     {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe0}
  45 };
  46
  47 static char const * const *expected_method_list;
  48
  49 BOOL g_showRunnable = TRUE;
  50 BOOL g_isRunning = TRUE;
  51
  52 #define CHECK_EXPECTED_METHOD(method_name) \
  53     do { \
  54         trace("%s\n", method_name); \
  55         ok(*expected_method_list != NULL, "Extra method %s called\n", method_name); \
  56         if (*expected_method_list) \
  57         { \
  58             ok(!strcmp(*expected_method_list, method_name), "Expected %s to be called instead of %s\n", \
  59                 *expected_method_list, method_name); \
  60             expected_method_list++; \
  61         } \
  62     } while(0)
  63
  64 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
  65 {
  66     CHECK_EXPECTED_METHOD("OleObject_QueryInterface");
  67
  68     *ppv = NULL;
  69
  70     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IOleObject))
  71         *ppv = (void *)iface;
  72     else if (IsEqualIID(riid, &IID_IPersistStorage))
  73         *ppv = &OleObjectPersistStg;
  74     else if (IsEqualIID(riid, &IID_IOleCache))
  75         *ppv = cache;
  76     else if (IsEqualIID(riid, &IID_IRunnableObject) && g_showRunnable)
  77         *ppv = runnable;
  78
  79     if(*ppv) {
  80         IUnknown_AddRef((IUnknown*)*ppv);
  81         return S_OK;
  82     }
  83
  84     trace("OleObject_QueryInterface: returning E_NOINTERFACE\n");
  85     return E_NOINTERFACE;
  86 }
  87
  88 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
  89 {
  90     CHECK_EXPECTED_METHOD("OleObject_AddRef");
  91     return 2;
  92 }
  93
  94 static ULONG WINAPI OleObject_Release(IOleObject *iface)
  95 {
  96     CHECK_EXPECTED_METHOD("OleObject_Release");
  97     return 1;
  98 }
  99
 100 static HRESULT WINAPI OleObject_SetClientSite
 101     (
 102         IOleObject *iface,
 103         IOleClientSite *pClientSite
 104     )
 105 {
 106     CHECK_EXPECTED_METHOD("OleObject_SetClientSite");
 107     return S_OK;
 108 }
 109
 110 static HRESULT WINAPI OleObject_GetClientSite
 111     (
 112         IOleObject *iface,
 113         IOleClientSite **ppClientSite
 114     )
 115 {
 116     CHECK_EXPECTED_METHOD("OleObject_GetClientSite");
 117     return E_NOTIMPL;
 118 }
 119
 120 static HRESULT WINAPI OleObject_SetHostNames
 121     (
 122         IOleObject *iface,
 123         LPCOLESTR szContainerApp,
 124         LPCOLESTR szContainerObj
 125     )
 126 {
 127     CHECK_EXPECTED_METHOD("OleObject_SetHostNames");
 128     return S_OK;
 129 }
 130
 131 static HRESULT WINAPI OleObject_Close
 132     (
 133         IOleObject *iface,
 134         DWORD dwSaveOption
 135     )
 136 {
 137     CHECK_EXPECTED_METHOD("OleObject_Close");
 138     return S_OK;
 139 }
 140
 141 static HRESULT WINAPI OleObject_SetMoniker
 142     (
 143         IOleObject *iface,
 144         DWORD dwWhichMoniker,
 145         IMoniker *pmk
 146     )
 147 {
 148     CHECK_EXPECTED_METHOD("OleObject_SetMoniker");
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI OleObject_GetMoniker
 153     (
 154         IOleObject *iface,
 155         DWORD dwAssign,
 156         DWORD dwWhichMoniker,
 157         IMoniker **ppmk
 158     )
 159 {
 160     CHECK_EXPECTED_METHOD("OleObject_GetMoniker");
 161     return S_OK;
 162 }
 163
 164 static HRESULT WINAPI OleObject_InitFromData
 165     (
 166         IOleObject *iface,
 167         IDataObject *pDataObject,
 168         BOOL fCreation,
 169         DWORD dwReserved
 170     )
 171 {
 172     CHECK_EXPECTED_METHOD("OleObject_InitFromData");
 173     return S_OK;
 174 }
 175
 176 static HRESULT WINAPI OleObject_GetClipboardData
 177     (
 178         IOleObject *iface,
 179         DWORD dwReserved,
 180         IDataObject **ppDataObject
 181     )
 182 {
 183     CHECK_EXPECTED_METHOD("OleObject_GetClipboardData");
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI OleObject_DoVerb
 188     (
 189         IOleObject *iface,
 190         LONG iVerb,
 191         LPMSG lpmsg,
 192         IOleClientSite *pActiveSite,
 193         LONG lindex,
 194         HWND hwndParent,
 195         LPCRECT lprcPosRect
 196     )
 197 {
 198     CHECK_EXPECTED_METHOD("OleObject_DoVerb");
 199     return S_OK;
 200 }
 201
 202 static HRESULT WINAPI OleObject_EnumVerbs
 203     (
 204         IOleObject *iface,
 205         IEnumOLEVERB **ppEnumOleVerb
 206     )
 207 {
 208     CHECK_EXPECTED_METHOD("OleObject_EnumVerbs");
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI OleObject_Update
 213     (
 214         IOleObject *iface
 215     )
 216 {
 217     CHECK_EXPECTED_METHOD("OleObject_Update");
 218     return S_OK;
 219 }
 220
 221 static HRESULT WINAPI OleObject_IsUpToDate
 222     (
 223         IOleObject *iface
 224     )
 225 {
 226     CHECK_EXPECTED_METHOD("OleObject_IsUpToDate");
 227     return S_OK;
 228 }
 229
 230 static HRESULT WINAPI OleObject_GetUserClassID
 231 (
 232     IOleObject *iface,
 233     CLSID *pClsid
 234 )
 235 {
 236     CHECK_EXPECTED_METHOD("OleObject_GetUserClassID");
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI OleObject_GetUserType
 241 (
 242     IOleObject *iface,
 243     DWORD dwFormOfType,
 244     LPOLESTR *pszUserType
 245 )
 246 {
 247     CHECK_EXPECTED_METHOD("OleObject_GetUserType");
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI OleObject_SetExtent
 252 (
 253     IOleObject *iface,
 254     DWORD dwDrawAspect,
 255     SIZEL *psizel
 256 )
 257 {
 258     CHECK_EXPECTED_METHOD("OleObject_SetExtent");
 259     return S_OK;
 260 }
 261
 262 static HRESULT WINAPI OleObject_GetExtent
 263 (
 264     IOleObject *iface,
 265     DWORD dwDrawAspect,
 266     SIZEL *psizel
 267 )
 268 {
 269     CHECK_EXPECTED_METHOD("OleObject_GetExtent");
 270     return E_NOTIMPL;
 271 }
 272
 273 static HRESULT WINAPI OleObject_Advise
 274 (
 275     IOleObject *iface,
 276     IAdviseSink *pAdvSink,
 277     DWORD *pdwConnection
 278 )
 279 {
 280     CHECK_EXPECTED_METHOD("OleObject_Advise");
 281     return S_OK;
 282 }
 283
 284 static HRESULT WINAPI OleObject_Unadvise
 285 (
 286     IOleObject *iface,
 287     DWORD dwConnection
 288 )
 289 {
 290     CHECK_EXPECTED_METHOD("OleObject_Unadvise");
 291     return S_OK;
 292 }
 293
 294 static HRESULT WINAPI OleObject_EnumAdvise
 295 (
 296     IOleObject *iface,
 297     IEnumSTATDATA **ppenumAdvise
 298 )
 299 {
 300     CHECK_EXPECTED_METHOD("OleObject_EnumAdvise");
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI OleObject_GetMiscStatus
 305 (
 306     IOleObject *iface,
 307     DWORD dwAspect,
 308     DWORD *pdwStatus
 309 )
 310 {
 311     CHECK_EXPECTED_METHOD("OleObject_GetMiscStatus");
 312     *pdwStatus = DVASPECT_CONTENT;
 313     return S_OK;
 314 }
 315
 316 static HRESULT WINAPI OleObject_SetColorScheme
 317 (
 318     IOleObject *iface,
 319     LOGPALETTE *pLogpal
 320 )
 321 {
 322     CHECK_EXPECTED_METHOD("OleObject_SetColorScheme");
 323     return E_NOTIMPL;
 324 }
 325
 326 static const IOleObjectVtbl OleObjectVtbl =
 327 {
 328     OleObject_QueryInterface,
 329     OleObject_AddRef,
 330     OleObject_Release,
 331     OleObject_SetClientSite,
 332     OleObject_GetClientSite,
 333     OleObject_SetHostNames,
 334     OleObject_Close,
 335     OleObject_SetMoniker,
 336     OleObject_GetMoniker,
 337     OleObject_InitFromData,
 338     OleObject_GetClipboardData,
 339     OleObject_DoVerb,
 340     OleObject_EnumVerbs,
 341     OleObject_Update,
 342     OleObject_IsUpToDate,
 343     OleObject_GetUserClassID,
 344     OleObject_GetUserType,
 345     OleObject_SetExtent,
 346     OleObject_GetExtent,
 347     OleObject_Advise,
 348     OleObject_Unadvise,
 349     OleObject_EnumAdvise,
 350     OleObject_GetMiscStatus,
 351     OleObject_SetColorScheme
 352 };
 353
 354 static IOleObject OleObject = { &OleObjectVtbl };
 355
 356 static HRESULT WINAPI OleObjectPersistStg_QueryInterface(IPersistStorage *iface, REFIID riid, void **ppv)
 357 {
 358     trace("OleObjectPersistStg_QueryInterface\n");
 359     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 360 }
 361
 362 static ULONG WINAPI OleObjectPersistStg_AddRef(IPersistStorage *iface)
 363 {
 364     CHECK_EXPECTED_METHOD("OleObjectPersistStg_AddRef");
 365     return 2;
 366 }
 367
 368 static ULONG WINAPI OleObjectPersistStg_Release(IPersistStorage *iface)
 369 {
 370     CHECK_EXPECTED_METHOD("OleObjectPersistStg_Release");
 371     return 1;
 372 }
 373
 374 static HRESULT WINAPI OleObjectPersistStg_GetClassId(IPersistStorage *iface, CLSID *clsid)
 375 {
 376     CHECK_EXPECTED_METHOD("OleObjectPersistStg_GetClassId");
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI OleObjectPersistStg_IsDirty
 381 (
 382     IPersistStorage *iface
 383 )
 384 {
 385     CHECK_EXPECTED_METHOD("OleObjectPersistStg_IsDirty");
 386     return S_OK;
 387 }
 388
 389 static HRESULT WINAPI OleObjectPersistStg_InitNew
 390 (
 391     IPersistStorage *iface,
 392     IStorage *pStg
 393 )
 394 {
 395     CHECK_EXPECTED_METHOD("OleObjectPersistStg_InitNew");
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI OleObjectPersistStg_Load
 400 (
 401     IPersistStorage *iface,
 402     IStorage *pStg
 403 )
 404 {
 405     CHECK_EXPECTED_METHOD("OleObjectPersistStg_Load");
 406     return S_OK;
 407 }
 408
 409 static HRESULT WINAPI OleObjectPersistStg_Save
 410 (
 411     IPersistStorage *iface,
 412     IStorage *pStgSave,
 413     BOOL fSameAsLoad
 414 )
 415 {
 416     CHECK_EXPECTED_METHOD("OleObjectPersistStg_Save");
 417     return S_OK;
 418 }
 419
 420 static HRESULT WINAPI OleObjectPersistStg_SaveCompleted
 421 (
 422     IPersistStorage *iface,
 423     IStorage *pStgNew
 424 )
 425 {
 426     CHECK_EXPECTED_METHOD("OleObjectPersistStg_SaveCompleted");
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI OleObjectPersistStg_HandsOffStorage
 431 (
 432     IPersistStorage *iface
 433 )
 434 {
 435     CHECK_EXPECTED_METHOD("OleObjectPersistStg_HandsOffStorage");
 436     return S_OK;
 437 }
 438
 439 static const IPersistStorageVtbl OleObjectPersistStgVtbl =
 440 {
 441     OleObjectPersistStg_QueryInterface,
 442     OleObjectPersistStg_AddRef,
 443     OleObjectPersistStg_Release,
 444     OleObjectPersistStg_GetClassId,
 445     OleObjectPersistStg_IsDirty,
 446     OleObjectPersistStg_InitNew,
 447     OleObjectPersistStg_Load,
 448     OleObjectPersistStg_Save,
 449     OleObjectPersistStg_SaveCompleted,
 450     OleObjectPersistStg_HandsOffStorage
 451 };
 452
 453 static IPersistStorage OleObjectPersistStg = { &OleObjectPersistStgVtbl };
 454
 455 static HRESULT WINAPI OleObjectCache_QueryInterface(IOleCache *iface, REFIID riid, void **ppv)
 456 {
 457     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 458 }
 459
 460 static ULONG WINAPI OleObjectCache_AddRef(IOleCache *iface)
 461 {
 462     CHECK_EXPECTED_METHOD("OleObjectCache_AddRef");
 463     return 2;
 464 }
 465
 466 static ULONG WINAPI OleObjectCache_Release(IOleCache *iface)
 467 {
 468     CHECK_EXPECTED_METHOD("OleObjectCache_Release");
 469     return 1;
 470 }
 471
 472 static HRESULT WINAPI OleObjectCache_Cache
 473 (
 474     IOleCache *iface,
 475     FORMATETC *pformatetc,
 476     DWORD advf,
 477     DWORD *pdwConnection
 478 )
 479 {
 480     CHECK_EXPECTED_METHOD("OleObjectCache_Cache");
 481     return S_OK;
 482 }
 483
 484 static HRESULT WINAPI OleObjectCache_Uncache
 485 (
 486     IOleCache *iface,
 487     DWORD dwConnection
 488 )
 489 {
 490     CHECK_EXPECTED_METHOD("OleObjectCache_Uncache");
 491     return S_OK;
 492 }
 493
 494 static HRESULT WINAPI OleObjectCache_EnumCache
 495 (
 496     IOleCache *iface,
 497     IEnumSTATDATA **ppenumSTATDATA
 498 )
 499 {
 500     CHECK_EXPECTED_METHOD("OleObjectCache_EnumCache");
 501     return S_OK;
 502 }
 503
 504
 505 static HRESULT WINAPI OleObjectCache_InitCache
 506 (
 507     IOleCache *iface,
 508     IDataObject *pDataObject
 509 )
 510 {
 511     CHECK_EXPECTED_METHOD("OleObjectCache_InitCache");
 512     return S_OK;
 513 }
 514
 515
 516 static HRESULT WINAPI OleObjectCache_SetData
 517 (
 518     IOleCache *iface,
 519     FORMATETC *pformatetc,
 520     STGMEDIUM *pmedium,
 521     BOOL fRelease
 522 )
 523 {
 524     CHECK_EXPECTED_METHOD("OleObjectCache_SetData");
 525     return S_OK;
 526 }
 527
 528
 529 static const IOleCacheVtbl OleObjectCacheVtbl =
 530 {
 531     OleObjectCache_QueryInterface,
 532     OleObjectCache_AddRef,
 533     OleObjectCache_Release,
 534     OleObjectCache_Cache,
 535     OleObjectCache_Uncache,
 536     OleObjectCache_EnumCache,
 537     OleObjectCache_InitCache,
 538     OleObjectCache_SetData
 539 };
 540
 541 static IOleCache OleObjectCache = { &OleObjectCacheVtbl };
 542
 543 static HRESULT WINAPI OleObjectCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 544 {
 545     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
 546     {
 547         *ppv = iface;
 548         IUnknown_AddRef(iface);
 549         return S_OK;
 550     }
 551     *ppv = NULL;
 552     return E_NOINTERFACE;
 553 }
 554
 555 static ULONG WINAPI OleObjectCF_AddRef(IClassFactory *iface)
 556 {
 557     return 2;
 558 }
 559
 560 static ULONG WINAPI OleObjectCF_Release(IClassFactory *iface)
 561 {
 562     return 1;
 563 }
 564
 565 static HRESULT WINAPI OleObjectCF_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID riid, void **ppv)
 566 {
 567     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 568 }
 569
 570 static HRESULT WINAPI OleObjectCF_LockServer(IClassFactory *iface, BOOL lock)
 571 {
 572     return S_OK;
 573 }
 574
 575 static const IClassFactoryVtbl OleObjectCFVtbl =
 576 {
 577     OleObjectCF_QueryInterface,
 578     OleObjectCF_AddRef,
 579     OleObjectCF_Release,
 580     OleObjectCF_CreateInstance,
 581     OleObjectCF_LockServer
 582 };
 583
 584 static IClassFactory OleObjectCF = { &OleObjectCFVtbl };
 585
 586 static HRESULT WINAPI OleObjectRunnable_QueryInterface(IRunnableObject *iface, REFIID riid, void **ppv)
 587 {
 588     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 589 }
 590
 591 static ULONG WINAPI OleObjectRunnable_AddRef(IRunnableObject *iface)
 592 {
 593     CHECK_EXPECTED_METHOD("OleObjectRunnable_AddRef");
 594     return 2;
 595 }
 596
 597 static ULONG WINAPI OleObjectRunnable_Release(IRunnableObject *iface)
 598 {
 599     CHECK_EXPECTED_METHOD("OleObjectRunnable_Release");
 600     return 1;
 601 }
 602
 603 static HRESULT WINAPI OleObjectRunnable_GetRunningClass(
 604     IRunnableObject *iface,
 605     LPCLSID lpClsid)
 606 {
 607     CHECK_EXPECTED_METHOD("OleObjectRunnable_GetRunningClass");
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT WINAPI OleObjectRunnable_Run(
 612     IRunnableObject *iface,
 613     LPBINDCTX pbc)
 614 {
 615     CHECK_EXPECTED_METHOD("OleObjectRunnable_Run");
 616     return S_OK;
 617 }
 618
 619 static BOOL WINAPI OleObjectRunnable_IsRunning(IRunnableObject *iface)
 620 {
 621     CHECK_EXPECTED_METHOD("OleObjectRunnable_IsRunning");
 622     return g_isRunning;
 623 }
 624
 625 static HRESULT WINAPI OleObjectRunnable_LockRunning(
 626     IRunnableObject *iface,
 627     BOOL fLock,
 628     BOOL fLastUnlockCloses)
 629 {
 630     CHECK_EXPECTED_METHOD("OleObjectRunnable_LockRunning");
 631     return S_OK;
 632 }
 633
 634 static HRESULT WINAPI OleObjectRunnable_SetContainedObject(
 635     IRunnableObject *iface,
 636     BOOL fContained)
 637 {
 638     CHECK_EXPECTED_METHOD("OleObjectRunnable_SetContainedObject");
 639     return S_OK;
 640 }
 641
 642 static const IRunnableObjectVtbl OleObjectRunnableVtbl =
 643 {
 644     OleObjectRunnable_QueryInterface,
 645     OleObjectRunnable_AddRef,
 646     OleObjectRunnable_Release,
 647     OleObjectRunnable_GetRunningClass,
 648     OleObjectRunnable_Run,
 649     OleObjectRunnable_IsRunning,
 650     OleObjectRunnable_LockRunning,
 651     OleObjectRunnable_SetContainedObject
 652 };
 653
 654 static IRunnableObject OleObjectRunnable = { &OleObjectRunnableVtbl };
 655
 656 static const CLSID CLSID_Equation3 = {0x0002CE02, 0x0000, 0x0000, {0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46} };
 657
 658 static void test_OleCreate(IStorage *pStorage)
 659 {
 660     HRESULT hr;
 661     IOleObject *pObject;
 662     FORMATETC formatetc;
 663     static const char *methods_olerender_none[] =
 664     {
 665         "OleObject_QueryInterface",
 666         "OleObject_AddRef",
 667         "OleObject_QueryInterface",
 668         "OleObjectPersistStg_AddRef",
 669         "OleObjectPersistStg_InitNew",
 670         "OleObjectPersistStg_Release",
 671         "OleObject_Release",
 672         NULL
 673     };
 674     static const char *methods_olerender_draw[] =
 675     {
 676         "OleObject_QueryInterface",
 677         "OleObject_AddRef",
 678         "OleObject_QueryInterface",
 679         "OleObjectPersistStg_AddRef",
 680         "OleObjectPersistStg_InitNew",
 681         "OleObjectPersistStg_Release",
 682         "OleObject_QueryInterface",
 683         "OleObjectRunnable_AddRef",
 684         "OleObjectRunnable_Run",
 685         "OleObjectRunnable_Release",
 686         "OleObject_QueryInterface",
 687         "OleObjectCache_AddRef",
 688         "OleObjectCache_Cache",
 689         "OleObjectCache_Release",
 690         "OleObject_Release",
 691         NULL
 692     };
 693     static const char *methods_olerender_format[] =
 694     {
 695         "OleObject_QueryInterface",
 696         "OleObject_AddRef",
 697         "OleObject_QueryInterface",
 698         "OleObject_AddRef",
 699         "OleObject_GetMiscStatus",
 700         "OleObject_QueryInterface",
 701         "OleObjectPersistStg_AddRef",
 702         "OleObjectPersistStg_InitNew",
 703         "OleObjectPersistStg_Release",
 704         "OleObject_SetClientSite",
 705         "OleObject_Release",
 706         "OleObject_QueryInterface",
 707         "OleObjectRunnable_AddRef",
 708         "OleObjectRunnable_Run",
 709         "OleObjectRunnable_Release",
 710         "OleObject_QueryInterface",
 711         "OleObjectCache_AddRef",
 712         "OleObjectCache_Cache",
 713         "OleObjectCache_Release",
 714         "OleObject_Release",
 715         NULL
 716     };
 717     static const char *methods_olerender_asis[] =
 718     {
 719         "OleObject_QueryInterface",
 720         "OleObject_AddRef",
 721         "OleObject_QueryInterface",
 722         "OleObjectPersistStg_AddRef",
 723         "OleObjectPersistStg_InitNew",
 724         "OleObjectPersistStg_Release",
 725         "OleObject_Release",
 726         NULL
 727     };
 728     static const char *methods_olerender_draw_no_runnable[] =
 729     {
 730         "OleObject_QueryInterface",
 731         "OleObject_AddRef",
 732         "OleObject_QueryInterface",
 733         "OleObjectPersistStg_AddRef",
 734         "OleObjectPersistStg_InitNew",
 735         "OleObjectPersistStg_Release",
 736         "OleObject_QueryInterface",
 737         "OleObject_QueryInterface",
 738         "OleObjectCache_AddRef",
 739         "OleObjectCache_Cache",
 740         "OleObjectCache_Release",
 741         "OleObject_Release",
 742         NULL
 743     };
 744     static const char *methods_olerender_draw_no_cache[] =
 745     {
 746         "OleObject_QueryInterface",
 747         "OleObject_AddRef",
 748         "OleObject_QueryInterface",
 749         "OleObjectPersistStg_AddRef",
 750         "OleObjectPersistStg_InitNew",
 751         "OleObjectPersistStg_Release",
 752         "OleObject_QueryInterface",
 753         "OleObjectRunnable_AddRef",
 754         "OleObjectRunnable_Run",
 755         "OleObjectRunnable_Release",
 756         "OleObject_QueryInterface",
 757         "OleObject_Release",
 758         NULL
 759     };
 760
 761     runnable = &OleObjectRunnable;
 762     cache = &OleObjectCache;
 763     expected_method_list = methods_olerender_none;
 764     trace("OleCreate with OLERENDER_NONE:\n");
 765     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_NONE, NULL, NULL, pStorage, (void **)&pObject);
 766     ok_ole_success(hr, "OleCreate");
 767     IOleObject_Release(pObject);
 768     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 769
 770     expected_method_list = methods_olerender_draw;
 771     trace("OleCreate with OLERENDER_DRAW:\n");
 772     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
 773     ok_ole_success(hr, "OleCreate");
 774     IOleObject_Release(pObject);
 775     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 776
 777     formatetc.cfFormat = CF_TEXT;
 778     formatetc.ptd = NULL;
 779     formatetc.dwAspect = DVASPECT_CONTENT;
 780     formatetc.lindex = -1;
 781     formatetc.tymed = TYMED_HGLOBAL;
 782     expected_method_list = methods_olerender_format;
 783     trace("OleCreate with OLERENDER_FORMAT:\n");
 784     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_FORMAT, &formatetc, (IOleClientSite *)0xdeadbeef, pStorage, (void **)&pObject);
 785     ok_ole_success(hr, "OleCreate");
 786     IOleObject_Release(pObject);
 787     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 788
 789     expected_method_list = methods_olerender_asis;
 790     trace("OleCreate with OLERENDER_ASIS:\n");
 791     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_ASIS, NULL, NULL, pStorage, (void **)&pObject);
 792     ok_ole_success(hr, "OleCreate");
 793     IOleObject_Release(pObject);
 794     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 795
 796     runnable = NULL;
 797     expected_method_list = methods_olerender_draw_no_runnable;
 798     trace("OleCreate with OLERENDER_DRAW (no IOlObjectRunnable):\n");
 799     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
 800     ok_ole_success(hr, "OleCreate");
 801     IOleObject_Release(pObject);
 802     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 803
 804     runnable = &OleObjectRunnable;
 805     cache = NULL;
 806     expected_method_list = methods_olerender_draw_no_cache;
 807     trace("OleCreate with OLERENDER_DRAW (no IOlObjectRunnable):\n");
 808     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
 809     ok_ole_success(hr, "OleCreate");
 810     IOleObject_Release(pObject);
 811     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 812     trace("end\n");
 813 }
 814
 815 static void test_OleLoad(IStorage *pStorage)
 816 {
 817     HRESULT hr;
 818     IOleObject *pObject;
 819
 820     static const char *methods_oleload[] =
 821     {
 822         "OleObject_QueryInterface",
 823         "OleObject_AddRef",
 824         "OleObject_QueryInterface",
 825         "OleObject_AddRef",
 826         "OleObject_GetMiscStatus",
 827         "OleObject_QueryInterface",
 828         "OleObjectPersistStg_AddRef",
 829         "OleObjectPersistStg_Load",
 830         "OleObjectPersistStg_Release",
 831         "OleObject_SetClientSite",
 832         "OleObject_Release",
 833         "OleObject_QueryInterface",
 834         "OleObject_Release",
 835         NULL
 836     };
 837
 838     expected_method_list = methods_oleload;
 839     trace("OleLoad:\n");
 840     hr = OleLoad(pStorage, &IID_IOleObject, (IOleClientSite *)0xdeadbeef, (void **)&pObject);
 841     ok_ole_success(hr, "OleLoad");
 842     IOleObject_Release(pObject);
 843     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 844 }
 845
 846 static BOOL STDMETHODCALLTYPE draw_continue(ULONG_PTR param)
 847 {
 848     CHECK_EXPECTED_METHOD("draw_continue");
 849     return TRUE;
 850 }
 851
 852 static HRESULT WINAPI AdviseSink_QueryInterface(IAdviseSink *iface, REFIID riid, void **ppv)
 853 {
 854     if (IsEqualIID(riid, &IID_IAdviseSink) || IsEqualIID(riid, &IID_IUnknown))
 855     {
 856         *ppv = iface;
 857         IUnknown_AddRef(iface);
 858         return S_OK;
 859     }
 860     *ppv = NULL;
 861     return E_NOINTERFACE;
 862 }
 863
 864 static ULONG WINAPI AdviseSink_AddRef(IAdviseSink *iface)
 865 {
 866     return 2;
 867 }
 868
 869 static ULONG WINAPI AdviseSink_Release(IAdviseSink *iface)
 870 {
 871     return 1;
 872 }
 873
 874
 875 static void WINAPI AdviseSink_OnDataChange(
 876     IAdviseSink *iface,
 877     FORMATETC *pFormatetc,
 878     STGMEDIUM *pStgmed)
 879 {
 880     CHECK_EXPECTED_METHOD("AdviseSink_OnDataChange");
 881 }
 882
 883 static void WINAPI AdviseSink_OnViewChange(
 884     IAdviseSink *iface,
 885     DWORD dwAspect,
 886     LONG lindex)
 887 {
 888     CHECK_EXPECTED_METHOD("AdviseSink_OnViewChange");
 889 }
 890
 891 static void WINAPI AdviseSink_OnRename(
 892     IAdviseSink *iface,
 893     IMoniker *pmk)
 894 {
 895     CHECK_EXPECTED_METHOD("AdviseSink_OnRename");
 896 }
 897
 898 static void WINAPI AdviseSink_OnSave(IAdviseSink *iface)
 899 {
 900     CHECK_EXPECTED_METHOD("AdviseSink_OnSave");
 901 }
 902
 903 static void WINAPI AdviseSink_OnClose(IAdviseSink *iface)
 904 {
 905     CHECK_EXPECTED_METHOD("AdviseSink_OnClose");
 906 }
 907
 908 static const IAdviseSinkVtbl AdviseSinkVtbl =
 909 {
 910     AdviseSink_QueryInterface,
 911     AdviseSink_AddRef,
 912     AdviseSink_Release,
 913     AdviseSink_OnDataChange,
 914     AdviseSink_OnViewChange,
 915     AdviseSink_OnRename,
 916     AdviseSink_OnSave,
 917     AdviseSink_OnClose
 918 };
 919
 920 static IAdviseSink AdviseSink = { &AdviseSinkVtbl };
 921
 922 static HRESULT WINAPI DataObject_QueryInterface(
 923             IDataObject*     iface,
 924             REFIID           riid,
 925             void**           ppvObject)
 926 {
 927     if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
 928     {
 929         *ppvObject = iface;
 930         return S_OK;
 931     }
 932     *ppvObject = NULL;
 933     return S_OK;
 934 }
 935
 936 static ULONG WINAPI DataObject_AddRef(
 937             IDataObject*     iface)
 938 {
 939     return 2;
 940 }
 941
 942 static ULONG WINAPI DataObject_Release(
 943             IDataObject*     iface)
 944 {
 945     return 1;
 946 }
 947
 948 static HRESULT WINAPI DataObject_GetData(
 949         IDataObject*     iface,
 950         LPFORMATETC      pformatetcIn,
 951         STGMEDIUM*       pmedium)
 952 {
 953     CHECK_EXPECTED_METHOD("DataObject_GetData");
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI DataObject_GetDataHere(
 958         IDataObject*     iface,
 959         LPFORMATETC      pformatetc,
 960         STGMEDIUM*       pmedium)
 961 {
 962     CHECK_EXPECTED_METHOD("DataObject_GetDataHere");
 963     return E_NOTIMPL;
 964 }
 965
 966 static HRESULT WINAPI DataObject_QueryGetData(
 967         IDataObject*     iface,
 968         LPFORMATETC      pformatetc)
 969 {
 970     CHECK_EXPECTED_METHOD("DataObject_QueryGetData");
 971     return S_OK;
 972 }
 973
 974 static HRESULT WINAPI DataObject_GetCanonicalFormatEtc(
 975         IDataObject*     iface,
 976         LPFORMATETC      pformatectIn,
 977         LPFORMATETC      pformatetcOut)
 978 {
 979     CHECK_EXPECTED_METHOD("DataObject_GetCanonicalFormatEtc");
 980     return E_NOTIMPL;
 981 }
 982
 983 static HRESULT WINAPI DataObject_SetData(
 984         IDataObject*     iface,
 985         LPFORMATETC      pformatetc,
 986         STGMEDIUM*       pmedium,
 987         BOOL             fRelease)
 988 {
 989     CHECK_EXPECTED_METHOD("DataObject_SetData");
 990     return E_NOTIMPL;
 991 }
 992
 993 static HRESULT WINAPI DataObject_EnumFormatEtc(
 994         IDataObject*     iface,
 995         DWORD            dwDirection,
 996         IEnumFORMATETC** ppenumFormatEtc)
 997 {
 998     CHECK_EXPECTED_METHOD("DataObject_EnumFormatEtc");
 999     return E_NOTIMPL;
1000 }
1001
1002 static HRESULT WINAPI DataObject_DAdvise(
1003         IDataObject*     iface,
1004         FORMATETC*       pformatetc,
1005         DWORD            advf,
1006         IAdviseSink*     pAdvSink,
1007         DWORD*           pdwConnection)
1008 {
1009     CHECK_EXPECTED_METHOD("DataObject_DAdvise");
1010     *pdwConnection = 1;
1011     return S_OK;
1012 }
1013
1014 static HRESULT WINAPI DataObject_DUnadvise(
1015         IDataObject*     iface,
1016         DWORD            dwConnection)
1017 {
1018     CHECK_EXPECTED_METHOD("DataObject_DUnadvise");
1019     return S_OK;
1020 }
1021
1022 static HRESULT WINAPI DataObject_EnumDAdvise(
1023         IDataObject*     iface,
1024         IEnumSTATDATA**  ppenumAdvise)
1025 {
1026     CHECK_EXPECTED_METHOD("DataObject_EnumDAdvise");
1027     return OLE_E_ADVISENOTSUPPORTED;
1028 }
1029
1030 static IDataObjectVtbl DataObjectVtbl =
1031 {
1032     DataObject_QueryInterface,
1033     DataObject_AddRef,
1034     DataObject_Release,
1035     DataObject_GetData,
1036     DataObject_GetDataHere,
1037     DataObject_QueryGetData,
1038     DataObject_GetCanonicalFormatEtc,
1039     DataObject_SetData,
1040     DataObject_EnumFormatEtc,
1041     DataObject_DAdvise,
1042     DataObject_DUnadvise,
1043     DataObject_EnumDAdvise
1044 };
1045
1046 static IDataObject DataObject = { &DataObjectVtbl };
1047
1048 static void test_data_cache(void)
1049 {
1050     HRESULT hr;
1051     IOleCache2 *pOleCache;
1052     IStorage *pStorage;
1053     IPersistStorage *pPS;
1054     IViewObject *pViewObject;
1055     IOleCacheControl *pOleCacheControl;
1056     FORMATETC fmtetc;
1057     STGMEDIUM stgmedium;
1058     DWORD dwConnection;
1059     DWORD dwFreeze;
1060     RECTL rcBounds;
1061     HDC hdcMem;
1062     CLSID clsid;
1063     char szSystemDir[MAX_PATH];
1064     WCHAR wszPath[MAX_PATH];
1065     static const WCHAR wszShell32[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0};
1066
1067     static const char *methods_cacheinitnew[] =
1068     {
1069         "AdviseSink_OnViewChange",
1070         "AdviseSink_OnViewChange",
1071         "draw_continue",
1072         "DataObject_DAdvise",
1073         "DataObject_DAdvise",
1074         "DataObject_DUnadvise",
1075         "DataObject_DUnadvise",
1076         NULL
1077     };
1078     static const char *methods_cacheload[] =
1079     {
1080         "AdviseSink_OnViewChange",
1081         "draw_continue",
1082         "draw_continue",
1083         "draw_continue",
1084         "DataObject_GetData",
1085         "DataObject_GetData",
1086         "DataObject_GetData",
1087         NULL
1088     };
1089
1090     GetSystemDirectory(szSystemDir, sizeof(szSystemDir)/sizeof(szSystemDir[0]));
1091
1092     expected_method_list = methods_cacheinitnew;
1093
1094     fmtetc.cfFormat = CF_METAFILEPICT;
1095     fmtetc.dwAspect = DVASPECT_ICON;
1096     fmtetc.lindex = -1;
1097     fmtetc.ptd = NULL;
1098     fmtetc.tymed = TYMED_MFPICT;
1099
1100     hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1101     ok_ole_success(hr, "StgCreateDocfile");
1102
1103     /* Test with new data */
1104
1105     hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1106     ok_ole_success(hr, "CreateDataCache");
1107
1108     hr = IOleCache_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1109     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1110     hr = IOleCache_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1111     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1112     hr = IOleCache_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
1113     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1114
1115     hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1116     ok_ole_success(hr, "IViewObject_SetAdvise");
1117
1118     hr = IPersistStorage_InitNew(pPS, pStorage);
1119     ok_ole_success(hr, "IPersistStorage_InitNew");
1120
1121     hr = IPersistStorage_IsDirty(pPS);
1122     ok_ole_success(hr, "IPersistStorage_IsDirty");
1123
1124     hr = IPersistStorage_GetClassID(pPS, &clsid);
1125     ok_ole_success(hr, "IPersistStorage_GetClassID");
1126     ok(IsEqualCLSID(&clsid, &IID_NULL), "clsid should be blank\n");
1127
1128     hr = IOleCache_Uncache(pOleCache, 0xdeadbeef);
1129     ok(hr == OLE_E_NOCONNECTION, "IOleCache_Uncache with invalid value should return OLE_E_NOCONNECTION instead of 0x%x\n", hr);
1130
1131     for (fmtetc.cfFormat = CF_TEXT; fmtetc.cfFormat < CF_MAX; fmtetc.cfFormat++)
1132     {
1133         int i;
1134         fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1135         for (i = 0; i < 7; i++)
1136         {
1137             fmtetc.tymed = 1 << i;
1138             hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1139             if ((fmtetc.cfFormat == CF_METAFILEPICT && fmtetc.tymed == TYMED_MFPICT) ||
1140                 (fmtetc.cfFormat == CF_BITMAP && fmtetc.tymed == TYMED_GDI) ||
1141                 (fmtetc.cfFormat == CF_DIB && fmtetc.tymed == TYMED_HGLOBAL) ||
1142                 (fmtetc.cfFormat == CF_ENHMETAFILE && fmtetc.tymed == TYMED_ENHMF))
1143                 ok(hr == S_OK, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned S_OK instead of 0x%08x\n",
1144                     fmtetc.cfFormat, fmtetc.tymed, hr);
1145             else if (fmtetc.tymed == TYMED_HGLOBAL)
1146                 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED,
1147                     "IOleCache_Cache cfFormat = %d, tymed = %d should have returned CACHE_S_FORMATETC_NOTSUPPORTED instead of 0x%08x\n",
1148                     fmtetc.cfFormat, fmtetc.tymed, hr);
1149             else
1150                 ok(hr == DV_E_TYMED, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned DV_E_TYMED instead of 0x%08x\n",
1151                     fmtetc.cfFormat, fmtetc.tymed, hr);
1152             if (SUCCEEDED(hr))
1153             {
1154                 hr = IOleCache_Uncache(pOleCache, dwConnection);
1155                 ok_ole_success(hr, "IOleCache_Uncache");
1156             }
1157         }
1158     }
1159
1160     fmtetc.cfFormat = CF_BITMAP;
1161     fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1162     fmtetc.tymed = TYMED_GDI;
1163     hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1164     ok_ole_success(hr, "IOleCache_Cache");
1165
1166     fmtetc.cfFormat = 0;
1167     fmtetc.dwAspect = DVASPECT_ICON;
1168     fmtetc.tymed = TYMED_MFPICT;
1169     hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1170     ok_ole_success(hr, "IOleCache_Cache");
1171
1172     MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszPath, sizeof(wszPath)/sizeof(wszPath[0]));
1173     memcpy(wszPath+lstrlenW(wszPath), wszShell32, sizeof(wszShell32));
1174
1175     fmtetc.cfFormat = CF_METAFILEPICT;
1176     stgmedium.tymed = TYMED_MFPICT;
1177     U(stgmedium).hMetaFilePict = OleMetafilePictFromIconAndLabel(
1178         LoadIcon(NULL, IDI_APPLICATION), wszPath, wszPath, 0);
1179     stgmedium.pUnkForRelease = NULL;
1180
1181     fmtetc.dwAspect = DVASPECT_CONTENT;
1182     hr = IOleCache_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1183     ok(hr == OLE_E_BLANK, "IOleCache_SetData for aspect not in cache should have return OLE_E_BLANK instead of 0x%08x\n", hr);
1184
1185     fmtetc.dwAspect = DVASPECT_ICON;
1186     hr = IOleCache_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1187     ok_ole_success(hr, "IOleCache_SetData");
1188
1189     hr = IViewObject_Freeze(pViewObject, DVASPECT_ICON, -1, NULL, &dwFreeze);
1190     todo_wine {
1191     ok_ole_success(hr, "IViewObject_Freeze");
1192     hr = IViewObject_Freeze(pViewObject, DVASPECT_CONTENT, -1, NULL, &dwFreeze);
1193     ok(hr == OLE_E_BLANK, "IViewObject_Freeze with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1194     }
1195
1196     rcBounds.left = 0;
1197     rcBounds.top = 0;
1198     rcBounds.right = 100;
1199     rcBounds.bottom = 100;
1200     hdcMem = CreateCompatibleDC(NULL);
1201
1202     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1203     ok_ole_success(hr, "IViewObject_Draw");
1204
1205     hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1206     ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1207
1208     DeleteDC(hdcMem);
1209
1210     hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
1211     todo_wine {
1212     ok_ole_success(hr, "IOleCacheControl_OnRun");
1213     }
1214
1215     hr = IPersistStorage_Save(pPS, pStorage, TRUE);
1216     ok_ole_success(hr, "IPersistStorage_Save");
1217
1218     hr = IPersistStorage_SaveCompleted(pPS, NULL);
1219     ok_ole_success(hr, "IPersistStorage_SaveCompleted");
1220
1221     hr = IPersistStorage_IsDirty(pPS);
1222     ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1223
1224     IPersistStorage_Release(pPS);
1225     IViewObject_Release(pViewObject);
1226     IOleCache_Release(pOleCache);
1227     IOleCacheControl_Release(pOleCacheControl);
1228
1229     todo_wine {
1230     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1231     }
1232
1233     /* Test with loaded data */
1234     trace("Testing loaded data with CreateDataCache:\n");
1235     expected_method_list = methods_cacheload;
1236
1237     hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1238     ok_ole_success(hr, "CreateDataCache");
1239
1240     hr = IOleCache_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1241     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1242     hr = IOleCache_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1243     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1244
1245     hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1246     ok_ole_success(hr, "IViewObject_SetAdvise");
1247
1248     hr = IPersistStorage_Load(pPS, pStorage);
1249     ok_ole_success(hr, "IPersistStorage_Load");
1250
1251     hr = IPersistStorage_IsDirty(pPS);
1252     ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1253
1254     fmtetc.cfFormat = 0;
1255     fmtetc.dwAspect = DVASPECT_ICON;
1256     fmtetc.lindex = -1;
1257     fmtetc.ptd = NULL;
1258     fmtetc.tymed = TYMED_MFPICT;
1259     hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1260     ok(hr == CACHE_S_SAMECACHE, "IOleCache_Cache with already loaded data format type should return CACHE_S_SAMECACHE instead of 0x%x\n", hr);
1261
1262     rcBounds.left = 0;
1263     rcBounds.top = 0;
1264     rcBounds.right = 100;
1265     rcBounds.bottom = 100;
1266     hdcMem = CreateCompatibleDC(NULL);
1267
1268     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1269     ok_ole_success(hr, "IViewObject_Draw");
1270
1271     hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1272     ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1273
1274     /* unload the cached storage object, causing it to be reloaded */
1275     hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1276     ok_ole_success(hr, "IOleCache2_DiscardCache");
1277     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1278     ok_ole_success(hr, "IViewObject_Draw");
1279
1280     /* unload the cached storage object, but don't allow it to be reloaded */
1281     hr = IPersistStorage_HandsOffStorage(pPS);
1282     ok_ole_success(hr, "IPersistStorage_HandsOffStorage");
1283     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1284     ok_ole_success(hr, "IViewObject_Draw");
1285     hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1286     ok_ole_success(hr, "IOleCache2_DiscardCache");
1287     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1288     ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1289
1290     DeleteDC(hdcMem);
1291
1292     todo_wine {
1293     hr = IOleCache_InitCache(pOleCache, &DataObject);
1294     ok(hr == CACHE_E_NOCACHE_UPDATED, "IOleCache_InitCache should have returned CACHE_E_NOCACHE_UPDATED instead of 0x%08x\n", hr);
1295     }
1296
1297     IPersistStorage_Release(pPS);
1298     IViewObject_Release(pViewObject);
1299     IOleCache_Release(pOleCache);
1300
1301     todo_wine {
1302     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1303     }
1304
1305     IStorage_Release(pStorage);
1306     ReleaseStgMedium(&stgmedium);
1307 }
1308
1309 static void test_default_handler(void)
1310 {
1311     HRESULT hr;
1312     IOleObject *pObject;
1313     IRunnableObject *pRunnableObject;
1314     IOleClientSite *pClientSite;
1315     IDataObject *pDataObject;
1316     SIZEL sizel;
1317     DWORD dwStatus;
1318     CLSID clsid;
1319     LPOLESTR pszUserType;
1320     LOGPALETTE palette;
1321     DWORD dwAdvConn;
1322     IMoniker *pMoniker;
1323     FORMATETC fmtetc;
1324     IOleInPlaceObject *pInPlaceObj;
1325     IEnumOLEVERB *pEnumVerbs;
1326     static const WCHAR wszUnknown[] = {'U','n','k','n','o','w','n',0};
1327     static const WCHAR wszHostName[] = {'W','i','n','e',' ','T','e','s','t',' ','P','r','o','g','r','a','m',0};
1328     static const WCHAR wszDelim[] = {'!',0};
1329
1330     hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IOleObject, (void **)&pObject);
1331     ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance should have failed with REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1332
1333     hr = OleCreateDefaultHandler(&CLSID_WineTest, NULL, &IID_IOleObject, (void **)&pObject);
1334     ok_ole_success(hr, "OleCreateDefaultHandler");
1335
1336     hr = IOleObject_QueryInterface(pObject, &IID_IOleInPlaceObject, (void **)&pInPlaceObj);
1337     ok(hr == E_NOINTERFACE, "IOleObject_QueryInterface(&IID_IOleInPlaceObject) should return E_NOINTERFACE instead of 0x%08x\n", hr);
1338
1339     hr = IOleObject_Advise(pObject, &AdviseSink, &dwAdvConn);
1340     ok_ole_success(hr, "IOleObject_Advise");
1341
1342     hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
1343     ok_ole_success(hr, "IOleObject_Close");
1344
1345     /* FIXME: test IOleObject_EnumAdvise */
1346
1347     hr = IOleObject_EnumVerbs(pObject, &pEnumVerbs);
1348     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_EnumVerbs should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1349
1350     hr = IOleObject_GetClientSite(pObject, &pClientSite);
1351     ok_ole_success(hr, "IOleObject_GetClientSite");
1352
1353     hr = IOleObject_GetClipboardData(pObject, 0, &pDataObject);
1354     ok(hr == OLE_E_NOTRUNNING,
1355        "IOleObject_GetClipboardData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n",
1356        hr);
1357
1358     hr = IOleObject_GetExtent(pObject, DVASPECT_CONTENT, &sizel);
1359     ok(hr == OLE_E_BLANK, "IOleObject_GetExtent should have returned OLE_E_BLANK instead of 0x%08x\n",
1360        hr);
1361
1362     hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
1363     todo_wine
1364     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_GetMiscStatus should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1365
1366     hr = IOleObject_GetUserClassID(pObject, &clsid);
1367     ok_ole_success(hr, "IOleObject_GetUserClassID");
1368     ok(IsEqualCLSID(&clsid, &CLSID_WineTest), "clsid != CLSID_WineTest\n");
1369
1370     hr = IOleObject_GetUserType(pObject, USERCLASSTYPE_FULL, &pszUserType);
1371     todo_wine {
1372     ok_ole_success(hr, "IOleObject_GetUserType");
1373     ok(!lstrcmpW(pszUserType, wszUnknown), "Retrieved user type was wrong\n");
1374     }
1375
1376     hr = IOleObject_InitFromData(pObject, NULL, TRUE, 0);
1377     ok(hr == OLE_E_NOTRUNNING, "IOleObject_InitFromData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1378
1379     hr = IOleObject_IsUpToDate(pObject);
1380     ok(hr == OLE_E_NOTRUNNING, "IOleObject_IsUpToDate should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1381
1382     palette.palNumEntries = 1;
1383     palette.palVersion = 2;
1384     memset(&palette.palPalEntry[0], 0, sizeof(palette.palPalEntry[0]));
1385     hr = IOleObject_SetColorScheme(pObject, &palette);
1386     ok(hr == OLE_E_NOTRUNNING, "IOleObject_SetColorScheme should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1387
1388     sizel.cx = sizel.cy = 0;
1389     hr = IOleObject_SetExtent(pObject, DVASPECT_CONTENT, &sizel);
1390
1391     hr = IOleObject_SetHostNames(pObject, wszHostName, NULL);
1392     ok_ole_success(hr, "IOleObject_SetHostNames");
1393
1394     hr = CreateItemMoniker(wszDelim, wszHostName, &pMoniker);
1395     ok_ole_success(hr, "CreateItemMoniker");
1396     hr = IOleObject_SetMoniker(pObject, OLEWHICHMK_CONTAINER, pMoniker);
1397     ok_ole_success(hr, "IOleObject_SetMoniker");
1398
1399     hr = IOleObject_GetMoniker(pObject, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &pMoniker);
1400     ok(hr == E_FAIL, "IOleObject_GetMoniker should have returned E_FAIL instead of 0x%08x\n", hr);
1401
1402     hr = IOleObject_Update(pObject);
1403     todo_wine
1404     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Update should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1405
1406     hr = IOleObject_QueryInterface(pObject, &IID_IDataObject, (void **)&pDataObject);
1407     ok_ole_success(hr, "IOleObject_QueryInterface");
1408
1409     fmtetc.cfFormat = CF_TEXT;
1410     fmtetc.ptd = NULL;
1411     fmtetc.dwAspect = DVASPECT_CONTENT;
1412     fmtetc.lindex = -1;
1413     fmtetc.tymed = TYMED_NULL;
1414     hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
1415     ok_ole_success(hr, "IDataObject_DAdvise");
1416
1417     fmtetc.cfFormat = CF_ENHMETAFILE;
1418     fmtetc.ptd = NULL;
1419     fmtetc.dwAspect = DVASPECT_CONTENT;
1420     fmtetc.lindex = -1;
1421     fmtetc.tymed = TYMED_ENHMF;
1422     hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
1423     ok_ole_success(hr, "IDataObject_DAdvise");
1424
1425     fmtetc.cfFormat = CF_ENHMETAFILE;
1426     fmtetc.ptd = NULL;
1427     fmtetc.dwAspect = DVASPECT_CONTENT;
1428     fmtetc.lindex = -1;
1429     fmtetc.tymed = TYMED_ENHMF;
1430     hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
1431     todo_wine
1432     ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1433
1434     fmtetc.cfFormat = CF_TEXT;
1435     fmtetc.ptd = NULL;
1436     fmtetc.dwAspect = DVASPECT_CONTENT;
1437     fmtetc.lindex = -1;
1438     fmtetc.tymed = TYMED_NULL;
1439     hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
1440     todo_wine
1441     ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1442
1443     hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnableObject);
1444     ok_ole_success(hr, "IOleObject_QueryInterface");
1445
1446     hr = IRunnableObject_SetContainedObject(pRunnableObject, TRUE);
1447     ok_ole_success(hr, "IRunnableObject_SetContainedObject");
1448
1449     hr = IRunnableObject_Run(pRunnableObject, NULL);
1450     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Run should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1451
1452     hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
1453     ok_ole_success(hr, "IOleObject_Close");
1454
1455     IRunnableObject_Release(pRunnableObject);
1456     IOleObject_Release(pObject);
1457 }
1458
1459 void test_runnable(void)
1460 {
1461     static const char *methods_query_runnable[] =
1462     {
1463         "OleObject_QueryInterface",
1464         "OleObjectRunnable_AddRef",
1465         "OleObjectRunnable_IsRunning",
1466         "OleObjectRunnable_Release",
1467         NULL
1468     };
1469
1470     static const char *methods_no_runnable[] =
1471     {
1472         "OleObject_QueryInterface",
1473         NULL
1474     };
1475
1476     IOleObject *object = (IOleObject *)&OleObject;
1477
1478     expected_method_list = methods_query_runnable;
1479     ok(OleIsRunning(object), "Object should be running\n");
1480     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1481
1482     g_isRunning = FALSE;
1483     expected_method_list = methods_query_runnable;
1484     ok(OleIsRunning(object) == FALSE, "Object should not be running\n");
1485     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1486
1487     g_showRunnable = FALSE;  /* QueryInterface(IID_IRunnableObject, ...) will fail */
1488     expected_method_list = methods_no_runnable;
1489     ok(OleIsRunning(object), "Object without IRunnableObject should be running\n");
1490     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1491
1492     g_isRunning = TRUE;
1493     g_showRunnable = TRUE;
1494 }
1495
1496 START_TEST(ole2)
1497 {
1498     DWORD dwRegister;
1499     IStorage *pStorage;
1500     STATSTG statstg;
1501     HRESULT hr;
1502
1503     CoInitialize(NULL);
1504
1505     hr = CoRegisterClassObject(&CLSID_Equation3, (IUnknown *)&OleObjectCF, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
1506     ok_ole_success(hr, "CoRegisterClassObject");
1507
1508     hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1509     ok_ole_success(hr, "StgCreateDocfile");
1510
1511     test_OleCreate(pStorage);
1512
1513     hr = IStorage_Stat(pStorage, &statstg, STATFLAG_NONAME);
1514     ok_ole_success(hr, "IStorage_Stat");
1515     ok(IsEqualCLSID(&CLSID_Equation3, &statstg.clsid), "Wrong CLSID in storage\n");
1516
1517     test_OleLoad(pStorage);
1518
1519     IStorage_Release(pStorage);
1520
1521     hr = CoRevokeClassObject(dwRegister);
1522     ok_ole_success(hr, "CoRevokeClassObject");
1523
1524     test_data_cache();
1525     test_default_handler();
1526     test_runnable();
1527
1528     CoUninitialize();
1529 }