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