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

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