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

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