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