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), /* win2k */
 848        "OleLoad failed with error 0x%08x\n", hr);
 849     ok_ole_success(hr, "OleLoad");
 850     if (pObject)
 851     {
 852         IOleObject_Release(pObject);
 853         ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 854     }
 855 }
 856
 857 static BOOL STDMETHODCALLTYPE draw_continue(ULONG_PTR param)
 858 {
 859     CHECK_EXPECTED_METHOD("draw_continue");
 860     return TRUE;
 861 }
 862
 863 static HRESULT WINAPI AdviseSink_QueryInterface(IAdviseSink *iface, REFIID riid, void **ppv)
 864 {
 865     if (IsEqualIID(riid, &IID_IAdviseSink) || IsEqualIID(riid, &IID_IUnknown))
 866     {
 867         *ppv = iface;
 868         IUnknown_AddRef(iface);
 869         return S_OK;
 870     }
 871     *ppv = NULL;
 872     return E_NOINTERFACE;
 873 }
 874
 875 static ULONG WINAPI AdviseSink_AddRef(IAdviseSink *iface)
 876 {
 877     return 2;
 878 }
 879
 880 static ULONG WINAPI AdviseSink_Release(IAdviseSink *iface)
 881 {
 882     return 1;
 883 }
 884
 885
 886 static void WINAPI AdviseSink_OnDataChange(
 887     IAdviseSink *iface,
 888     FORMATETC *pFormatetc,
 889     STGMEDIUM *pStgmed)
 890 {
 891     CHECK_EXPECTED_METHOD("AdviseSink_OnDataChange");
 892 }
 893
 894 static void WINAPI AdviseSink_OnViewChange(
 895     IAdviseSink *iface,
 896     DWORD dwAspect,
 897     LONG lindex)
 898 {
 899     CHECK_EXPECTED_METHOD("AdviseSink_OnViewChange");
 900 }
 901
 902 static void WINAPI AdviseSink_OnRename(
 903     IAdviseSink *iface,
 904     IMoniker *pmk)
 905 {
 906     CHECK_EXPECTED_METHOD("AdviseSink_OnRename");
 907 }
 908
 909 static void WINAPI AdviseSink_OnSave(IAdviseSink *iface)
 910 {
 911     CHECK_EXPECTED_METHOD("AdviseSink_OnSave");
 912 }
 913
 914 static void WINAPI AdviseSink_OnClose(IAdviseSink *iface)
 915 {
 916     CHECK_EXPECTED_METHOD("AdviseSink_OnClose");
 917 }
 918
 919 static const IAdviseSinkVtbl AdviseSinkVtbl =
 920 {
 921     AdviseSink_QueryInterface,
 922     AdviseSink_AddRef,
 923     AdviseSink_Release,
 924     AdviseSink_OnDataChange,
 925     AdviseSink_OnViewChange,
 926     AdviseSink_OnRename,
 927     AdviseSink_OnSave,
 928     AdviseSink_OnClose
 929 };
 930
 931 static IAdviseSink AdviseSink = { &AdviseSinkVtbl };
 932
 933 static HRESULT WINAPI DataObject_QueryInterface(
 934             IDataObject*     iface,
 935             REFIID           riid,
 936             void**           ppvObject)
 937 {
 938     if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
 939     {
 940         *ppvObject = iface;
 941         return S_OK;
 942     }
 943     *ppvObject = NULL;
 944     return S_OK;
 945 }
 946
 947 static ULONG WINAPI DataObject_AddRef(
 948             IDataObject*     iface)
 949 {
 950     return 2;
 951 }
 952
 953 static ULONG WINAPI DataObject_Release(
 954             IDataObject*     iface)
 955 {
 956     return 1;
 957 }
 958
 959 static HRESULT WINAPI DataObject_GetData(
 960         IDataObject*     iface,
 961         LPFORMATETC      pformatetcIn,
 962         STGMEDIUM*       pmedium)
 963 {
 964     CHECK_EXPECTED_METHOD("DataObject_GetData");
 965     return E_NOTIMPL;
 966 }
 967
 968 static HRESULT WINAPI DataObject_GetDataHere(
 969         IDataObject*     iface,
 970         LPFORMATETC      pformatetc,
 971         STGMEDIUM*       pmedium)
 972 {
 973     CHECK_EXPECTED_METHOD("DataObject_GetDataHere");
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI DataObject_QueryGetData(
 978         IDataObject*     iface,
 979         LPFORMATETC      pformatetc)
 980 {
 981     CHECK_EXPECTED_METHOD("DataObject_QueryGetData");
 982     return S_OK;
 983 }
 984
 985 static HRESULT WINAPI DataObject_GetCanonicalFormatEtc(
 986         IDataObject*     iface,
 987         LPFORMATETC      pformatectIn,
 988         LPFORMATETC      pformatetcOut)
 989 {
 990     CHECK_EXPECTED_METHOD("DataObject_GetCanonicalFormatEtc");
 991     return E_NOTIMPL;
 992 }
 993
 994 static HRESULT WINAPI DataObject_SetData(
 995         IDataObject*     iface,
 996         LPFORMATETC      pformatetc,
 997         STGMEDIUM*       pmedium,
 998         BOOL             fRelease)
 999 {
1000     CHECK_EXPECTED_METHOD("DataObject_SetData");
1001     return E_NOTIMPL;
1002 }
1003
1004 static HRESULT WINAPI DataObject_EnumFormatEtc(
1005         IDataObject*     iface,
1006         DWORD            dwDirection,
1007         IEnumFORMATETC** ppenumFormatEtc)
1008 {
1009     CHECK_EXPECTED_METHOD("DataObject_EnumFormatEtc");
1010     return E_NOTIMPL;
1011 }
1012
1013 static HRESULT WINAPI DataObject_DAdvise(
1014         IDataObject*     iface,
1015         FORMATETC*       pformatetc,
1016         DWORD            advf,
1017         IAdviseSink*     pAdvSink,
1018         DWORD*           pdwConnection)
1019 {
1020     CHECK_EXPECTED_METHOD("DataObject_DAdvise");
1021     *pdwConnection = 1;
1022     return S_OK;
1023 }
1024
1025 static HRESULT WINAPI DataObject_DUnadvise(
1026         IDataObject*     iface,
1027         DWORD            dwConnection)
1028 {
1029     CHECK_EXPECTED_METHOD("DataObject_DUnadvise");
1030     return S_OK;
1031 }
1032
1033 static HRESULT WINAPI DataObject_EnumDAdvise(
1034         IDataObject*     iface,
1035         IEnumSTATDATA**  ppenumAdvise)
1036 {
1037     CHECK_EXPECTED_METHOD("DataObject_EnumDAdvise");
1038     return OLE_E_ADVISENOTSUPPORTED;
1039 }
1040
1041 static IDataObjectVtbl DataObjectVtbl =
1042 {
1043     DataObject_QueryInterface,
1044     DataObject_AddRef,
1045     DataObject_Release,
1046     DataObject_GetData,
1047     DataObject_GetDataHere,
1048     DataObject_QueryGetData,
1049     DataObject_GetCanonicalFormatEtc,
1050     DataObject_SetData,
1051     DataObject_EnumFormatEtc,
1052     DataObject_DAdvise,
1053     DataObject_DUnadvise,
1054     DataObject_EnumDAdvise
1055 };
1056
1057 static IDataObject DataObject = { &DataObjectVtbl };
1058
1059 static void test_data_cache(void)
1060 {
1061     HRESULT hr;
1062     IOleCache2 *pOleCache;
1063     IStorage *pStorage;
1064     IPersistStorage *pPS;
1065     IViewObject *pViewObject;
1066     IOleCacheControl *pOleCacheControl;
1067     FORMATETC fmtetc;
1068     STGMEDIUM stgmedium;
1069     DWORD dwConnection;
1070     DWORD dwFreeze;
1071     RECTL rcBounds;
1072     HDC hdcMem;
1073     CLSID clsid;
1074     char szSystemDir[MAX_PATH];
1075     WCHAR wszPath[MAX_PATH];
1076     static const WCHAR wszShell32[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0};
1077
1078     static const char *methods_cacheinitnew[] =
1079     {
1080         "AdviseSink_OnViewChange",
1081         "AdviseSink_OnViewChange",
1082         "draw_continue",
1083         "DataObject_DAdvise",
1084         "DataObject_DAdvise",
1085         "DataObject_DUnadvise",
1086         "DataObject_DUnadvise",
1087         NULL
1088     };
1089     static const char *methods_cacheload[] =
1090     {
1091         "AdviseSink_OnViewChange",
1092         "draw_continue",
1093         "draw_continue",
1094         "draw_continue",
1095         "DataObject_GetData",
1096         "DataObject_GetData",
1097         "DataObject_GetData",
1098         NULL
1099     };
1100
1101     GetSystemDirectory(szSystemDir, sizeof(szSystemDir)/sizeof(szSystemDir[0]));
1102
1103     expected_method_list = methods_cacheinitnew;
1104
1105     fmtetc.cfFormat = CF_METAFILEPICT;
1106     fmtetc.dwAspect = DVASPECT_ICON;
1107     fmtetc.lindex = -1;
1108     fmtetc.ptd = NULL;
1109     fmtetc.tymed = TYMED_MFPICT;
1110
1111     hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1112     ok_ole_success(hr, "StgCreateDocfile");
1113
1114     /* Test with new data */
1115
1116     hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1117     ok_ole_success(hr, "CreateDataCache");
1118
1119     hr = IOleCache_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1120     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1121     hr = IOleCache_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1122     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1123     hr = IOleCache_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
1124     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1125
1126     hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1127     ok_ole_success(hr, "IViewObject_SetAdvise");
1128
1129     hr = IPersistStorage_InitNew(pPS, pStorage);
1130     ok_ole_success(hr, "IPersistStorage_InitNew");
1131
1132     hr = IPersistStorage_IsDirty(pPS);
1133     ok_ole_success(hr, "IPersistStorage_IsDirty");
1134
1135     hr = IPersistStorage_GetClassID(pPS, &clsid);
1136     ok_ole_success(hr, "IPersistStorage_GetClassID");
1137     ok(IsEqualCLSID(&clsid, &IID_NULL), "clsid should be blank\n");
1138
1139     hr = IOleCache_Uncache(pOleCache, 0xdeadbeef);
1140     ok(hr == OLE_E_NOCONNECTION, "IOleCache_Uncache with invalid value should return OLE_E_NOCONNECTION instead of 0x%x\n", hr);
1141
1142     /* Both tests crash on NT4 and below. StgCreatePropSetStg is only available on w2k and above. */
1143     if (GetProcAddress(GetModuleHandleA("ole32.dll"), "StgCreatePropSetStg"))
1144     {
1145         hr = IOleCache_Cache(pOleCache, NULL, 0, &dwConnection);
1146         ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL fmtetc should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1147
1148         hr = IOleCache_Cache(pOleCache, NULL, 0, NULL);
1149         ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL pdwConnection should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1150     }
1151     else
1152     {
1153         skip("tests with NULL parameters will crash on NT4 and below\n");
1154     }
1155
1156     for (fmtetc.cfFormat = CF_TEXT; fmtetc.cfFormat < CF_MAX; fmtetc.cfFormat++)
1157     {
1158         int i;
1159         fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1160         for (i = 0; i < 7; i++)
1161         {
1162             fmtetc.tymed = 1 << i;
1163             hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1164             if ((fmtetc.cfFormat == CF_METAFILEPICT && fmtetc.tymed == TYMED_MFPICT) ||
1165                 (fmtetc.cfFormat == CF_BITMAP && fmtetc.tymed == TYMED_GDI) ||
1166                 (fmtetc.cfFormat == CF_DIB && fmtetc.tymed == TYMED_HGLOBAL) ||
1167                 (fmtetc.cfFormat == CF_ENHMETAFILE && fmtetc.tymed == TYMED_ENHMF))
1168                 ok(hr == S_OK, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned S_OK instead of 0x%08x\n",
1169                     fmtetc.cfFormat, fmtetc.tymed, hr);
1170             else if (fmtetc.tymed == TYMED_HGLOBAL)
1171                 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED,
1172                     "IOleCache_Cache cfFormat = %d, tymed = %d should have returned CACHE_S_FORMATETC_NOTSUPPORTED instead of 0x%08x\n",
1173                     fmtetc.cfFormat, fmtetc.tymed, hr);
1174             else
1175                 ok(hr == DV_E_TYMED, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned DV_E_TYMED instead of 0x%08x\n",
1176                     fmtetc.cfFormat, fmtetc.tymed, hr);
1177             if (SUCCEEDED(hr))
1178             {
1179                 hr = IOleCache_Uncache(pOleCache, dwConnection);
1180                 ok_ole_success(hr, "IOleCache_Uncache");
1181             }
1182         }
1183     }
1184
1185     fmtetc.cfFormat = CF_BITMAP;
1186     fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1187     fmtetc.tymed = TYMED_GDI;
1188     hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1189     ok_ole_success(hr, "IOleCache_Cache");
1190
1191     fmtetc.cfFormat = 0;
1192     fmtetc.dwAspect = DVASPECT_ICON;
1193     fmtetc.tymed = TYMED_MFPICT;
1194     hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1195     ok_ole_success(hr, "IOleCache_Cache");
1196
1197     MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszPath, sizeof(wszPath)/sizeof(wszPath[0]));
1198     memcpy(wszPath+lstrlenW(wszPath), wszShell32, sizeof(wszShell32));
1199
1200     fmtetc.cfFormat = CF_METAFILEPICT;
1201     stgmedium.tymed = TYMED_MFPICT;
1202     U(stgmedium).hMetaFilePict = OleMetafilePictFromIconAndLabel(
1203         LoadIcon(NULL, IDI_APPLICATION), wszPath, wszPath, 0);
1204     stgmedium.pUnkForRelease = NULL;
1205
1206     fmtetc.dwAspect = DVASPECT_CONTENT;
1207     hr = IOleCache_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1208     ok(hr == OLE_E_BLANK, "IOleCache_SetData for aspect not in cache should have return OLE_E_BLANK instead of 0x%08x\n", hr);
1209
1210     fmtetc.dwAspect = DVASPECT_ICON;
1211     hr = IOleCache_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1212     ok_ole_success(hr, "IOleCache_SetData");
1213
1214     hr = IViewObject_Freeze(pViewObject, DVASPECT_ICON, -1, NULL, &dwFreeze);
1215     todo_wine {
1216     ok_ole_success(hr, "IViewObject_Freeze");
1217     hr = IViewObject_Freeze(pViewObject, DVASPECT_CONTENT, -1, NULL, &dwFreeze);
1218     ok(hr == OLE_E_BLANK, "IViewObject_Freeze with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1219     }
1220
1221     rcBounds.left = 0;
1222     rcBounds.top = 0;
1223     rcBounds.right = 100;
1224     rcBounds.bottom = 100;
1225     hdcMem = CreateCompatibleDC(NULL);
1226
1227     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1228     ok_ole_success(hr, "IViewObject_Draw");
1229
1230     hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1231     ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1232
1233     DeleteDC(hdcMem);
1234
1235     hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
1236     todo_wine {
1237     ok_ole_success(hr, "IOleCacheControl_OnRun");
1238     }
1239
1240     hr = IPersistStorage_Save(pPS, pStorage, TRUE);
1241     ok_ole_success(hr, "IPersistStorage_Save");
1242
1243     hr = IPersistStorage_SaveCompleted(pPS, NULL);
1244     ok_ole_success(hr, "IPersistStorage_SaveCompleted");
1245
1246     hr = IPersistStorage_IsDirty(pPS);
1247     ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1248
1249     IPersistStorage_Release(pPS);
1250     IViewObject_Release(pViewObject);
1251     IOleCache_Release(pOleCache);
1252     IOleCacheControl_Release(pOleCacheControl);
1253
1254     todo_wine {
1255     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1256     }
1257
1258     /* Test with loaded data */
1259     trace("Testing loaded data with CreateDataCache:\n");
1260     expected_method_list = methods_cacheload;
1261
1262     hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1263     ok_ole_success(hr, "CreateDataCache");
1264
1265     hr = IOleCache_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1266     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1267     hr = IOleCache_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1268     ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1269
1270     hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1271     ok_ole_success(hr, "IViewObject_SetAdvise");
1272
1273     hr = IPersistStorage_Load(pPS, pStorage);
1274     ok_ole_success(hr, "IPersistStorage_Load");
1275
1276     hr = IPersistStorage_IsDirty(pPS);
1277     ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1278
1279     fmtetc.cfFormat = 0;
1280     fmtetc.dwAspect = DVASPECT_ICON;
1281     fmtetc.lindex = -1;
1282     fmtetc.ptd = NULL;
1283     fmtetc.tymed = TYMED_MFPICT;
1284     hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1285     ok(hr == CACHE_S_SAMECACHE, "IOleCache_Cache with already loaded data format type should return CACHE_S_SAMECACHE instead of 0x%x\n", hr);
1286
1287     rcBounds.left = 0;
1288     rcBounds.top = 0;
1289     rcBounds.right = 100;
1290     rcBounds.bottom = 100;
1291     hdcMem = CreateCompatibleDC(NULL);
1292
1293     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1294     ok_ole_success(hr, "IViewObject_Draw");
1295
1296     hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1297     ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1298
1299     /* unload the cached storage object, causing it to be reloaded */
1300     hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1301     ok_ole_success(hr, "IOleCache2_DiscardCache");
1302     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1303     ok_ole_success(hr, "IViewObject_Draw");
1304
1305     /* unload the cached storage object, but don't allow it to be reloaded */
1306     hr = IPersistStorage_HandsOffStorage(pPS);
1307     ok_ole_success(hr, "IPersistStorage_HandsOffStorage");
1308     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1309     ok_ole_success(hr, "IViewObject_Draw");
1310     hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1311     ok_ole_success(hr, "IOleCache2_DiscardCache");
1312     hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1313     ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1314
1315     DeleteDC(hdcMem);
1316
1317     todo_wine {
1318     hr = IOleCache_InitCache(pOleCache, &DataObject);
1319     ok(hr == CACHE_E_NOCACHE_UPDATED, "IOleCache_InitCache should have returned CACHE_E_NOCACHE_UPDATED instead of 0x%08x\n", hr);
1320     }
1321
1322     IPersistStorage_Release(pPS);
1323     IViewObject_Release(pViewObject);
1324     IOleCache_Release(pOleCache);
1325
1326     todo_wine {
1327     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1328     }
1329
1330     IStorage_Release(pStorage);
1331     ReleaseStgMedium(&stgmedium);
1332 }
1333
1334 static void test_default_handler(void)
1335 {
1336     HRESULT hr;
1337     IOleObject *pObject;
1338     IRunnableObject *pRunnableObject;
1339     IOleClientSite *pClientSite;
1340     IDataObject *pDataObject;
1341     SIZEL sizel;
1342     DWORD dwStatus;
1343     CLSID clsid;
1344     LPOLESTR pszUserType;
1345     LOGPALETTE palette;
1346     DWORD dwAdvConn;
1347     IMoniker *pMoniker;
1348     FORMATETC fmtetc;
1349     IOleInPlaceObject *pInPlaceObj;
1350     IEnumOLEVERB *pEnumVerbs;
1351     static const WCHAR wszUnknown[] = {'U','n','k','n','o','w','n',0};
1352     static const WCHAR wszHostName[] = {'W','i','n','e',' ','T','e','s','t',' ','P','r','o','g','r','a','m',0};
1353     static const WCHAR wszDelim[] = {'!',0};
1354
1355     hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IOleObject, (void **)&pObject);
1356     ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance should have failed with REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1357
1358     hr = OleCreateDefaultHandler(&CLSID_WineTest, NULL, &IID_IOleObject, (void **)&pObject);
1359     ok_ole_success(hr, "OleCreateDefaultHandler");
1360
1361     hr = IOleObject_QueryInterface(pObject, &IID_IOleInPlaceObject, (void **)&pInPlaceObj);
1362     ok(hr == E_NOINTERFACE, "IOleObject_QueryInterface(&IID_IOleInPlaceObject) should return E_NOINTERFACE instead of 0x%08x\n", hr);
1363
1364     hr = IOleObject_Advise(pObject, &AdviseSink, &dwAdvConn);
1365     ok_ole_success(hr, "IOleObject_Advise");
1366
1367     hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
1368     ok_ole_success(hr, "IOleObject_Close");
1369
1370     /* FIXME: test IOleObject_EnumAdvise */
1371
1372     hr = IOleObject_EnumVerbs(pObject, &pEnumVerbs);
1373     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_EnumVerbs should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1374
1375     hr = IOleObject_GetClientSite(pObject, &pClientSite);
1376     ok_ole_success(hr, "IOleObject_GetClientSite");
1377
1378     hr = IOleObject_GetClipboardData(pObject, 0, &pDataObject);
1379     ok(hr == OLE_E_NOTRUNNING,
1380        "IOleObject_GetClipboardData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n",
1381        hr);
1382
1383     hr = IOleObject_GetExtent(pObject, DVASPECT_CONTENT, &sizel);
1384     ok(hr == OLE_E_BLANK, "IOleObject_GetExtent should have returned OLE_E_BLANK instead of 0x%08x\n",
1385        hr);
1386
1387     hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
1388     todo_wine
1389     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_GetMiscStatus should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1390
1391     hr = IOleObject_GetUserClassID(pObject, &clsid);
1392     ok_ole_success(hr, "IOleObject_GetUserClassID");
1393     ok(IsEqualCLSID(&clsid, &CLSID_WineTest), "clsid != CLSID_WineTest\n");
1394
1395     hr = IOleObject_GetUserType(pObject, USERCLASSTYPE_FULL, &pszUserType);
1396     todo_wine {
1397     ok_ole_success(hr, "IOleObject_GetUserType");
1398     ok(!lstrcmpW(pszUserType, wszUnknown), "Retrieved user type was wrong\n");
1399     }
1400
1401     hr = IOleObject_InitFromData(pObject, NULL, TRUE, 0);
1402     ok(hr == OLE_E_NOTRUNNING, "IOleObject_InitFromData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1403
1404     hr = IOleObject_IsUpToDate(pObject);
1405     ok(hr == OLE_E_NOTRUNNING, "IOleObject_IsUpToDate should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1406
1407     palette.palNumEntries = 1;
1408     palette.palVersion = 2;
1409     memset(&palette.palPalEntry[0], 0, sizeof(palette.palPalEntry[0]));
1410     hr = IOleObject_SetColorScheme(pObject, &palette);
1411     ok(hr == OLE_E_NOTRUNNING, "IOleObject_SetColorScheme should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1412
1413     sizel.cx = sizel.cy = 0;
1414     hr = IOleObject_SetExtent(pObject, DVASPECT_CONTENT, &sizel);
1415
1416     hr = IOleObject_SetHostNames(pObject, wszHostName, NULL);
1417     ok_ole_success(hr, "IOleObject_SetHostNames");
1418
1419     hr = CreateItemMoniker(wszDelim, wszHostName, &pMoniker);
1420     ok_ole_success(hr, "CreateItemMoniker");
1421     hr = IOleObject_SetMoniker(pObject, OLEWHICHMK_CONTAINER, pMoniker);
1422     ok_ole_success(hr, "IOleObject_SetMoniker");
1423     IMoniker_Release(pMoniker);
1424
1425     hr = IOleObject_GetMoniker(pObject, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &pMoniker);
1426     ok(hr == E_FAIL, "IOleObject_GetMoniker should have returned E_FAIL instead of 0x%08x\n", hr);
1427
1428     hr = IOleObject_Update(pObject);
1429     todo_wine
1430     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Update should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1431
1432     hr = IOleObject_QueryInterface(pObject, &IID_IDataObject, (void **)&pDataObject);
1433     ok_ole_success(hr, "IOleObject_QueryInterface");
1434
1435     fmtetc.cfFormat = CF_TEXT;
1436     fmtetc.ptd = NULL;
1437     fmtetc.dwAspect = DVASPECT_CONTENT;
1438     fmtetc.lindex = -1;
1439     fmtetc.tymed = TYMED_NULL;
1440     hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
1441     ok_ole_success(hr, "IDataObject_DAdvise");
1442
1443     fmtetc.cfFormat = CF_ENHMETAFILE;
1444     fmtetc.ptd = NULL;
1445     fmtetc.dwAspect = DVASPECT_CONTENT;
1446     fmtetc.lindex = -1;
1447     fmtetc.tymed = TYMED_ENHMF;
1448     hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
1449     ok_ole_success(hr, "IDataObject_DAdvise");
1450
1451     fmtetc.cfFormat = CF_ENHMETAFILE;
1452     fmtetc.ptd = NULL;
1453     fmtetc.dwAspect = DVASPECT_CONTENT;
1454     fmtetc.lindex = -1;
1455     fmtetc.tymed = TYMED_ENHMF;
1456     hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
1457     todo_wine
1458     ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1459
1460     fmtetc.cfFormat = CF_TEXT;
1461     fmtetc.ptd = NULL;
1462     fmtetc.dwAspect = DVASPECT_CONTENT;
1463     fmtetc.lindex = -1;
1464     fmtetc.tymed = TYMED_NULL;
1465     hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
1466     todo_wine
1467     ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1468
1469     hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnableObject);
1470     ok_ole_success(hr, "IOleObject_QueryInterface");
1471
1472     hr = IRunnableObject_SetContainedObject(pRunnableObject, TRUE);
1473     ok_ole_success(hr, "IRunnableObject_SetContainedObject");
1474
1475     hr = IRunnableObject_Run(pRunnableObject, NULL);
1476     ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Run should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1477
1478     hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
1479     ok_ole_success(hr, "IOleObject_Close");
1480
1481     IRunnableObject_Release(pRunnableObject);
1482     IOleObject_Release(pObject);
1483 }
1484
1485 void test_runnable(void)
1486 {
1487     static const char *methods_query_runnable[] =
1488     {
1489         "OleObject_QueryInterface",
1490         "OleObjectRunnable_AddRef",
1491         "OleObjectRunnable_IsRunning",
1492         "OleObjectRunnable_Release",
1493         NULL
1494     };
1495
1496     static const char *methods_no_runnable[] =
1497     {
1498         "OleObject_QueryInterface",
1499         NULL
1500     };
1501
1502     IOleObject *object = (IOleObject *)&OleObject;
1503
1504     expected_method_list = methods_query_runnable;
1505     ok(OleIsRunning(object), "Object should be running\n");
1506     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1507
1508     g_isRunning = FALSE;
1509     expected_method_list = methods_query_runnable;
1510     ok(OleIsRunning(object) == FALSE, "Object should not be running\n");
1511     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1512
1513     g_showRunnable = FALSE;  /* QueryInterface(IID_IRunnableObject, ...) will fail */
1514     expected_method_list = methods_no_runnable;
1515     ok(OleIsRunning(object), "Object without IRunnableObject should be running\n");
1516     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
1517
1518     g_isRunning = TRUE;
1519     g_showRunnable = TRUE;
1520 }
1521
1522 START_TEST(ole2)
1523 {
1524     DWORD dwRegister;
1525     IStorage *pStorage;
1526     STATSTG statstg;
1527     HRESULT hr;
1528
1529     CoInitialize(NULL);
1530
1531     hr = CoRegisterClassObject(&CLSID_Equation3, (IUnknown *)&OleObjectCF, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
1532     ok_ole_success(hr, "CoRegisterClassObject");
1533
1534     hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1535     ok_ole_success(hr, "StgCreateDocfile");
1536
1537     test_OleCreate(pStorage);
1538
1539     hr = IStorage_Stat(pStorage, &statstg, STATFLAG_NONAME);
1540     ok_ole_success(hr, "IStorage_Stat");
1541     ok(IsEqualCLSID(&CLSID_Equation3, &statstg.clsid), "Wrong CLSID in storage\n");
1542
1543     test_OleLoad(pStorage);
1544
1545     IStorage_Release(pStorage);
1546
1547     hr = CoRevokeClassObject(dwRegister);
1548     ok_ole_success(hr, "CoRevokeClassObject");
1549
1550     test_data_cache();
1551     test_default_handler();
1552     test_runnable();
1553
1554     CoUninitialize();
1555 }