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