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

   1 /*
   2  * Object Linking and Embedding Tests
   3  *
   4  * Copyright 2005 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "shlguid.h"
  29
  30 #include "wine/test.h"
  31
  32 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08lx\n", hr)
  33
  34 static IPersistStorage OleObjectPersistStg;
  35 static IOleCache *cache;
  36 static IRunnableObject *runnable;
  37
  38 static char const * const *expected_method_list;
  39
  40 #define CHECK_EXPECTED_METHOD(method_name) \
  41     do { \
  42         trace("%s\n", method_name); \
  43         ok(*expected_method_list != NULL, "Extra method %s called\n", method_name); \
  44         if (*expected_method_list) \
  45         { \
  46             ok(!strcmp(*expected_method_list, method_name), "Expected %s to be called instead of %s\n", \
  47                 *expected_method_list, method_name); \
  48             expected_method_list++; \
  49         } \
  50     } while(0)
  51
  52 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
  53 {
  54     CHECK_EXPECTED_METHOD("OleObject_QueryInterface");
  55
  56     *ppv = NULL;
  57
  58     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IOleObject))
  59         *ppv = (void *)iface;
  60     else if (IsEqualIID(riid, &IID_IPersistStorage))
  61         *ppv = &OleObjectPersistStg;
  62     else if (IsEqualIID(riid, &IID_IOleCache))
  63         *ppv = cache;
  64     else if (IsEqualIID(riid, &IID_IRunnableObject))
  65         *ppv = runnable;
  66
  67     if(*ppv) {
  68         IUnknown_AddRef((IUnknown*)*ppv);
  69         return S_OK;
  70     }
  71
  72     trace("OleObject_QueryInterface: returning E_NOINTERFACE\n");
  73     return E_NOINTERFACE;
  74 }
  75
  76 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
  77 {
  78     CHECK_EXPECTED_METHOD("OleObject_AddRef");
  79     return 2;
  80 }
  81
  82 static ULONG WINAPI OleObject_Release(IOleObject *iface)
  83 {
  84     CHECK_EXPECTED_METHOD("OleObject_Release");
  85     return 1;
  86 }
  87
  88 static HRESULT WINAPI OleObject_SetClientSite
  89     (
  90         IOleObject *iface,
  91         IOleClientSite *pClientSite
  92     )
  93 {
  94     CHECK_EXPECTED_METHOD("OleObject_SetClientSite");
  95     return S_OK;
  96 }
  97
  98 static HRESULT WINAPI OleObject_GetClientSite
  99     (
 100         IOleObject *iface,
 101         IOleClientSite **ppClientSite
 102     )
 103 {
 104     CHECK_EXPECTED_METHOD("OleObject_GetClientSite");
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI OleObject_SetHostNames
 109     (
 110         IOleObject *iface,
 111         LPCOLESTR szContainerApp,
 112         LPCOLESTR szContainerObj
 113     )
 114 {
 115     CHECK_EXPECTED_METHOD("OleObject_SetHostNames");
 116     return S_OK;
 117 }
 118
 119 static HRESULT WINAPI OleObject_Close
 120     (
 121         IOleObject *iface,
 122         DWORD dwSaveOption
 123     )
 124 {
 125     CHECK_EXPECTED_METHOD("OleObject_Close");
 126     return S_OK;
 127 }
 128
 129 static HRESULT WINAPI OleObject_SetMoniker
 130     (
 131         IOleObject *iface,
 132         DWORD dwWhichMoniker,
 133         IMoniker *pmk
 134     )
 135 {
 136     CHECK_EXPECTED_METHOD("OleObject_SetMoniker");
 137     return S_OK;
 138 }
 139
 140 static HRESULT WINAPI OleObject_GetMoniker
 141     (
 142         IOleObject *iface,
 143         DWORD dwAssign,
 144         DWORD dwWhichMoniker,
 145         IMoniker **ppmk
 146     )
 147 {
 148     CHECK_EXPECTED_METHOD("OleObject_GetMoniker");
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI OleObject_InitFromData
 153     (
 154         IOleObject *iface,
 155         IDataObject *pDataObject,
 156         BOOL fCreation,
 157         DWORD dwReserved
 158     )
 159 {
 160     CHECK_EXPECTED_METHOD("OleObject_InitFromData");
 161     return S_OK;
 162 }
 163
 164 static HRESULT WINAPI OleObject_GetClipboardData
 165     (
 166         IOleObject *iface,
 167         DWORD dwReserved,
 168         IDataObject **ppDataObject
 169     )
 170 {
 171     CHECK_EXPECTED_METHOD("OleObject_GetClipboardData");
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI OleObject_DoVerb
 176     (
 177         IOleObject *iface,
 178         LONG iVerb,
 179         LPMSG lpmsg,
 180         IOleClientSite *pActiveSite,
 181         LONG lindex,
 182         HWND hwndParent,
 183         LPCRECT lprcPosRect
 184     )
 185 {
 186     CHECK_EXPECTED_METHOD("OleObject_DoVerb");
 187     return S_OK;
 188 }
 189
 190 static HRESULT WINAPI OleObject_EnumVerbs
 191     (
 192         IOleObject *iface,
 193         IEnumOLEVERB **ppEnumOleVerb
 194     )
 195 {
 196     CHECK_EXPECTED_METHOD("OleObject_EnumVerbs");
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI OleObject_Update
 201     (
 202         IOleObject *iface
 203     )
 204 {
 205     CHECK_EXPECTED_METHOD("OleObject_Update");
 206     return S_OK;
 207 }
 208
 209 static HRESULT WINAPI OleObject_IsUpToDate
 210     (
 211         IOleObject *iface
 212     )
 213 {
 214     CHECK_EXPECTED_METHOD("OleObject_IsUpToDate");
 215     return S_OK;
 216 }
 217
 218 HRESULT WINAPI OleObject_GetUserClassID
 219 (
 220     IOleObject *iface,
 221     CLSID *pClsid
 222 )
 223 {
 224     CHECK_EXPECTED_METHOD("OleObject_GetUserClassID");
 225     return E_NOTIMPL;
 226 }
 227
 228 HRESULT WINAPI OleObject_GetUserType
 229 (
 230     IOleObject *iface,
 231     DWORD dwFormOfType,
 232     LPOLESTR *pszUserType
 233 )
 234 {
 235     CHECK_EXPECTED_METHOD("OleObject_GetUserType");
 236     return E_NOTIMPL;
 237 }
 238
 239 HRESULT WINAPI OleObject_SetExtent
 240 (
 241     IOleObject *iface,
 242     DWORD dwDrawAspect,
 243     SIZEL *psizel
 244 )
 245 {
 246     CHECK_EXPECTED_METHOD("OleObject_SetExtent");
 247     return S_OK;
 248 }
 249
 250 HRESULT WINAPI OleObject_GetExtent
 251 (
 252     IOleObject *iface,
 253     DWORD dwDrawAspect,
 254     SIZEL *psizel
 255 )
 256 {
 257     CHECK_EXPECTED_METHOD("OleObject_GetExtent");
 258     return E_NOTIMPL;
 259 }
 260
 261 HRESULT WINAPI OleObject_Advise
 262 (
 263     IOleObject *iface,
 264     IAdviseSink *pAdvSink,
 265     DWORD *pdwConnection
 266 )
 267 {
 268     CHECK_EXPECTED_METHOD("OleObject_Advise");
 269     return S_OK;
 270 }
 271
 272 HRESULT WINAPI OleObject_Unadvise
 273 (
 274     IOleObject *iface,
 275     DWORD dwConnection
 276 )
 277 {
 278     CHECK_EXPECTED_METHOD("OleObject_Unadvise");
 279     return S_OK;
 280 }
 281
 282 HRESULT WINAPI OleObject_EnumAdvise
 283 (
 284     IOleObject *iface,
 285     IEnumSTATDATA **ppenumAdvise
 286 )
 287 {
 288     CHECK_EXPECTED_METHOD("OleObject_EnumAdvise");
 289     return E_NOTIMPL;
 290 }
 291
 292 HRESULT WINAPI OleObject_GetMiscStatus
 293 (
 294     IOleObject *iface,
 295     DWORD dwAspect,
 296     DWORD *pdwStatus
 297 )
 298 {
 299     CHECK_EXPECTED_METHOD("OleObject_GetMiscStatus");
 300     *pdwStatus = DVASPECT_CONTENT;
 301     return S_OK;
 302 }
 303
 304 HRESULT WINAPI OleObject_SetColorScheme
 305 (
 306     IOleObject *iface,
 307     LOGPALETTE *pLogpal
 308 )
 309 {
 310     CHECK_EXPECTED_METHOD("OleObject_SetColorScheme");
 311     return E_NOTIMPL;
 312 }
 313
 314 static IOleObjectVtbl OleObjectVtbl =
 315 {
 316     OleObject_QueryInterface,
 317     OleObject_AddRef,
 318     OleObject_Release,
 319     OleObject_SetClientSite,
 320     OleObject_GetClientSite,
 321     OleObject_SetHostNames,
 322     OleObject_Close,
 323     OleObject_SetMoniker,
 324     OleObject_GetMoniker,
 325     OleObject_InitFromData,
 326     OleObject_GetClipboardData,
 327     OleObject_DoVerb,
 328     OleObject_EnumVerbs,
 329     OleObject_Update,
 330     OleObject_IsUpToDate,
 331     OleObject_GetUserClassID,
 332     OleObject_GetUserType,
 333     OleObject_SetExtent,
 334     OleObject_GetExtent,
 335     OleObject_Advise,
 336     OleObject_Unadvise,
 337     OleObject_EnumAdvise,
 338     OleObject_GetMiscStatus,
 339     OleObject_SetColorScheme
 340 };
 341
 342 static IOleObject OleObject = { &OleObjectVtbl };
 343
 344 static HRESULT WINAPI OleObjectPersistStg_QueryInterface(IPersistStorage *iface, REFIID riid, void **ppv)
 345 {
 346     trace("OleObjectPersistStg_QueryInterface\n");
 347     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 348 }
 349
 350 static ULONG WINAPI OleObjectPersistStg_AddRef(IPersistStorage *iface)
 351 {
 352     CHECK_EXPECTED_METHOD("OleObjectPersistStg_AddRef");
 353     return 2;
 354 }
 355
 356 static ULONG WINAPI OleObjectPersistStg_Release(IPersistStorage *iface)
 357 {
 358     CHECK_EXPECTED_METHOD("OleObjectPersistStg_Release");
 359     return 1;
 360 }
 361
 362 static HRESULT WINAPI OleObjectPersistStg_GetClassId(IPersistStorage *iface, CLSID *clsid)
 363 {
 364     CHECK_EXPECTED_METHOD("OleObjectPersistStg_GetClassId");
 365     return E_NOTIMPL;
 366 }
 367
 368 HRESULT WINAPI OleObjectPersistStg_IsDirty
 369 (
 370     IPersistStorage *iface
 371 )
 372 {
 373     CHECK_EXPECTED_METHOD("OleObjectPersistStg_IsDirty");
 374     return S_OK;
 375 }
 376
 377 HRESULT WINAPI OleObjectPersistStg_InitNew
 378 (
 379     IPersistStorage *iface,
 380     IStorage *pStg
 381 )
 382 {
 383     CHECK_EXPECTED_METHOD("OleObjectPersistStg_InitNew");
 384     return S_OK;
 385 }
 386
 387 HRESULT WINAPI OleObjectPersistStg_Load
 388 (
 389     IPersistStorage *iface,
 390     IStorage *pStg
 391 )
 392 {
 393     CHECK_EXPECTED_METHOD("OleObjectPersistStg_Load");
 394     return S_OK;
 395 }
 396
 397 HRESULT WINAPI OleObjectPersistStg_Save
 398 (
 399     IPersistStorage *iface,
 400     IStorage *pStgSave,
 401     BOOL fSameAsLoad
 402 )
 403 {
 404     CHECK_EXPECTED_METHOD("OleObjectPersistStg_Save");
 405     return S_OK;
 406 }
 407
 408 HRESULT WINAPI OleObjectPersistStg_SaveCompleted
 409 (
 410     IPersistStorage *iface,
 411     IStorage *pStgNew
 412 )
 413 {
 414     CHECK_EXPECTED_METHOD("OleObjectPersistStg_SaveCompleted");
 415     return S_OK;
 416 }
 417
 418 HRESULT WINAPI OleObjectPersistStg_HandsOffStorage
 419 (
 420     IPersistStorage *iface
 421 )
 422 {
 423     CHECK_EXPECTED_METHOD("OleObjectPersistStg_HandsOffStorage");
 424     return S_OK;
 425 }
 426
 427 static IPersistStorageVtbl OleObjectPersistStgVtbl =
 428 {
 429     OleObjectPersistStg_QueryInterface,
 430     OleObjectPersistStg_AddRef,
 431     OleObjectPersistStg_Release,
 432     OleObjectPersistStg_GetClassId,
 433     OleObjectPersistStg_IsDirty,
 434     OleObjectPersistStg_InitNew,
 435     OleObjectPersistStg_Load,
 436     OleObjectPersistStg_Save,
 437     OleObjectPersistStg_SaveCompleted,
 438     OleObjectPersistStg_HandsOffStorage
 439 };
 440
 441 static IPersistStorage OleObjectPersistStg = { &OleObjectPersistStgVtbl };
 442
 443 static HRESULT WINAPI OleObjectCache_QueryInterface(IOleCache *iface, REFIID riid, void **ppv)
 444 {
 445     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 446 }
 447
 448 static ULONG WINAPI OleObjectCache_AddRef(IOleCache *iface)
 449 {
 450     CHECK_EXPECTED_METHOD("OleObjectCache_AddRef");
 451     return 2;
 452 }
 453
 454 static ULONG WINAPI OleObjectCache_Release(IOleCache *iface)
 455 {
 456     CHECK_EXPECTED_METHOD("OleObjectCache_Release");
 457     return 1;
 458 }
 459
 460 HRESULT WINAPI OleObjectCache_Cache
 461 (
 462     IOleCache *iface,
 463     FORMATETC *pformatetc,
 464     DWORD advf,
 465     DWORD *pdwConnection
 466 )
 467 {
 468     CHECK_EXPECTED_METHOD("OleObjectCache_Cache");
 469     return S_OK;
 470 }
 471
 472 HRESULT WINAPI OleObjectCache_Uncache
 473 (
 474     IOleCache *iface,
 475     DWORD dwConnection
 476 )
 477 {
 478     CHECK_EXPECTED_METHOD("OleObjectCache_Uncache");
 479     return S_OK;
 480 }
 481
 482 HRESULT WINAPI OleObjectCache_EnumCache
 483 (
 484     IOleCache *iface,
 485     IEnumSTATDATA **ppenumSTATDATA
 486 )
 487 {
 488     CHECK_EXPECTED_METHOD("OleObjectCache_EnumCache");
 489     return S_OK;
 490 }
 491
 492
 493 HRESULT WINAPI OleObjectCache_InitCache
 494 (
 495     IOleCache *iface,
 496     IDataObject *pDataObject
 497 )
 498 {
 499     CHECK_EXPECTED_METHOD("OleObjectCache_InitCache");
 500     return S_OK;
 501 }
 502
 503
 504 HRESULT WINAPI OleObjectCache_SetData
 505 (
 506     IOleCache *iface,
 507     FORMATETC *pformatetc,
 508     STGMEDIUM *pmedium,
 509     BOOL fRelease
 510 )
 511 {
 512     CHECK_EXPECTED_METHOD("OleObjectCache_SetData");
 513     return S_OK;
 514 }
 515
 516
 517 static IOleCacheVtbl OleObjectCacheVtbl =
 518 {
 519     OleObjectCache_QueryInterface,
 520     OleObjectCache_AddRef,
 521     OleObjectCache_Release,
 522     OleObjectCache_Cache,
 523     OleObjectCache_Uncache,
 524     OleObjectCache_EnumCache,
 525     OleObjectCache_InitCache,
 526     OleObjectCache_SetData
 527 };
 528
 529 static IOleCache OleObjectCache = { &OleObjectCacheVtbl };
 530
 531 static HRESULT WINAPI OleObjectCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 532 {
 533     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
 534     {
 535         *ppv = iface;
 536         IUnknown_AddRef(iface);
 537         return S_OK;
 538     }
 539     *ppv = NULL;
 540     return E_NOINTERFACE;
 541 }
 542
 543 static ULONG WINAPI OleObjectCF_AddRef(IClassFactory *iface)
 544 {
 545     return 2;
 546 }
 547
 548 static ULONG WINAPI OleObjectCF_Release(IClassFactory *iface)
 549 {
 550     return 1;
 551 }
 552
 553 static HRESULT WINAPI OleObjectCF_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID riid, void **ppv)
 554 {
 555     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 556 }
 557
 558 static HRESULT WINAPI OleObjectCF_LockServer(IClassFactory *iface, BOOL lock)
 559 {
 560     return S_OK;
 561 }
 562
 563 static IClassFactoryVtbl OleObjectCFVtbl =
 564 {
 565     OleObjectCF_QueryInterface,
 566     OleObjectCF_AddRef,
 567     OleObjectCF_Release,
 568     OleObjectCF_CreateInstance,
 569     OleObjectCF_LockServer
 570 };
 571
 572 static IClassFactory OleObjectCF = { &OleObjectCFVtbl };
 573
 574 static HRESULT WINAPI OleObjectRunnable_QueryInterface(IRunnableObject *iface, REFIID riid, void **ppv)
 575 {
 576     return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
 577 }
 578
 579 static ULONG WINAPI OleObjectRunnable_AddRef(IRunnableObject *iface)
 580 {
 581     CHECK_EXPECTED_METHOD("OleObjectRunnable_AddRef");
 582     return 2;
 583 }
 584
 585 static ULONG WINAPI OleObjectRunnable_Release(IRunnableObject *iface)
 586 {
 587     CHECK_EXPECTED_METHOD("OleObjectRunnable_Release");
 588     return 1;
 589 }
 590
 591 HRESULT WINAPI OleObjectRunnable_GetRunningClass(
 592     IRunnableObject *iface,
 593     LPCLSID lpClsid)
 594 {
 595     CHECK_EXPECTED_METHOD("OleObjectRunnable_GetRunningClass");
 596     return E_NOTIMPL;
 597 }
 598
 599 HRESULT WINAPI OleObjectRunnable_Run(
 600     IRunnableObject *iface,
 601     LPBINDCTX pbc)
 602 {
 603     CHECK_EXPECTED_METHOD("OleObjectRunnable_Run");
 604     return S_OK;
 605 }
 606
 607 BOOL WINAPI OleObjectRunnable_IsRunning(IRunnableObject *iface)
 608 {
 609     CHECK_EXPECTED_METHOD("OleObjectRunnable_IsRunning");
 610     return TRUE;
 611 }
 612
 613 HRESULT WINAPI OleObjectRunnable_LockRunning(
 614     IRunnableObject *iface,
 615     BOOL fLock,
 616     BOOL fLastUnlockCloses)
 617 {
 618     CHECK_EXPECTED_METHOD("OleObjectRunnable_LockRunning");
 619     return S_OK;
 620 }
 621
 622 HRESULT WINAPI OleObjectRunnable_SetContainedObject(
 623     IRunnableObject *iface,
 624     BOOL fContained)
 625 {
 626     CHECK_EXPECTED_METHOD("OleObjectRunnable_SetContainedObject");
 627     return S_OK;
 628 }
 629
 630 static IRunnableObjectVtbl OleObjectRunnableVtbl =
 631 {
 632     OleObjectRunnable_QueryInterface,
 633     OleObjectRunnable_AddRef,
 634     OleObjectRunnable_Release,
 635     OleObjectRunnable_GetRunningClass,
 636     OleObjectRunnable_Run,
 637     OleObjectRunnable_IsRunning,
 638     OleObjectRunnable_LockRunning,
 639     OleObjectRunnable_SetContainedObject
 640 };
 641
 642 static IRunnableObject OleObjectRunnable = { &OleObjectRunnableVtbl };
 643
 644 static const CLSID CLSID_Equation3 = {0x0002CE02, 0x0000, 0x0000, {0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46} };
 645
 646 static void test_OleCreate(IStorage *pStorage)
 647 {
 648     HRESULT hr;
 649     IOleObject *pObject;
 650     FORMATETC formatetc;
 651     static const char *methods_olerender_none[] =
 652     {
 653         "OleObject_QueryInterface",
 654         "OleObject_AddRef",
 655         "OleObject_QueryInterface",
 656         "OleObjectPersistStg_AddRef",
 657         "OleObjectPersistStg_InitNew",
 658         "OleObjectPersistStg_Release",
 659         "OleObject_Release",
 660         NULL
 661     };
 662     static const char *methods_olerender_draw[] =
 663     {
 664         "OleObject_QueryInterface",
 665         "OleObject_AddRef",
 666         "OleObject_QueryInterface",
 667         "OleObjectPersistStg_AddRef",
 668         "OleObjectPersistStg_InitNew",
 669         "OleObjectPersistStg_Release",
 670         "OleObject_QueryInterface",
 671         "OleObjectRunnable_AddRef",
 672         "OleObjectRunnable_Run",
 673         "OleObjectRunnable_Release",
 674         "OleObject_QueryInterface",
 675         "OleObjectCache_AddRef",
 676         "OleObjectCache_Cache",
 677         "OleObjectCache_Release",
 678         "OleObject_Release",
 679         NULL
 680     };
 681     static const char *methods_olerender_format[] =
 682     {
 683         "OleObject_QueryInterface",
 684         "OleObject_AddRef",
 685         "OleObject_QueryInterface",
 686         "OleObject_AddRef",
 687         "OleObject_GetMiscStatus",
 688         "OleObject_QueryInterface",
 689         "OleObjectPersistStg_AddRef",
 690         "OleObjectPersistStg_InitNew",
 691         "OleObjectPersistStg_Release",
 692         "OleObject_SetClientSite",
 693         "OleObject_Release",
 694         "OleObject_QueryInterface",
 695         "OleObjectRunnable_AddRef",
 696         "OleObjectRunnable_Run",
 697         "OleObjectRunnable_Release",
 698         "OleObject_QueryInterface",
 699         "OleObjectCache_AddRef",
 700         "OleObjectCache_Cache",
 701         "OleObjectCache_Release",
 702         "OleObject_Release",
 703         NULL
 704     };
 705     static const char *methods_olerender_asis[] =
 706     {
 707         "OleObject_QueryInterface",
 708         "OleObject_AddRef",
 709         "OleObject_QueryInterface",
 710         "OleObjectPersistStg_AddRef",
 711         "OleObjectPersistStg_InitNew",
 712         "OleObjectPersistStg_Release",
 713         "OleObject_Release",
 714         NULL
 715     };
 716     static const char *methods_olerender_draw_no_runnable[] =
 717     {
 718         "OleObject_QueryInterface",
 719         "OleObject_AddRef",
 720         "OleObject_QueryInterface",
 721         "OleObjectPersistStg_AddRef",
 722         "OleObjectPersistStg_InitNew",
 723         "OleObjectPersistStg_Release",
 724         "OleObject_QueryInterface",
 725         "OleObject_QueryInterface",
 726         "OleObjectCache_AddRef",
 727         "OleObjectCache_Cache",
 728         "OleObjectCache_Release",
 729         "OleObject_Release",
 730         NULL
 731     };
 732     static const char *methods_olerender_draw_no_cache[] =
 733     {
 734         "OleObject_QueryInterface",
 735         "OleObject_AddRef",
 736         "OleObject_QueryInterface",
 737         "OleObjectPersistStg_AddRef",
 738         "OleObjectPersistStg_InitNew",
 739         "OleObjectPersistStg_Release",
 740         "OleObject_QueryInterface",
 741         "OleObjectRunnable_AddRef",
 742         "OleObjectRunnable_Run",
 743         "OleObjectRunnable_Release",
 744         "OleObject_QueryInterface",
 745         "OleObject_Release",
 746         NULL
 747     };
 748
 749     runnable = &OleObjectRunnable;
 750     cache = &OleObjectCache;
 751     expected_method_list = methods_olerender_none;
 752     trace("OleCreate with OLERENDER_NONE:\n");
 753     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_NONE, NULL, NULL, pStorage, (void **)&pObject);
 754     ok_ole_success(hr, "OleCreate");
 755     IOleObject_Release(pObject);
 756     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 757
 758     expected_method_list = methods_olerender_draw;
 759     trace("OleCreate with OLERENDER_DRAW:\n");
 760     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
 761     ok_ole_success(hr, "OleCreate");
 762     IOleObject_Release(pObject);
 763     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 764
 765     formatetc.cfFormat = CF_TEXT;
 766     formatetc.ptd = NULL;
 767     formatetc.dwAspect = DVASPECT_CONTENT;
 768     formatetc.lindex = -1;
 769     formatetc.tymed = TYMED_HGLOBAL;
 770     expected_method_list = methods_olerender_format;
 771     trace("OleCreate with OLERENDER_FORMAT:\n");
 772     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_FORMAT, &formatetc, (IOleClientSite *)0xdeadbeef, 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     expected_method_list = methods_olerender_asis;
 778     trace("OleCreate with OLERENDER_ASIS:\n");
 779     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_ASIS, NULL, NULL, pStorage, (void **)&pObject);
 780     ok_ole_success(hr, "OleCreate");
 781     IOleObject_Release(pObject);
 782     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 783
 784     runnable = NULL;
 785     expected_method_list = methods_olerender_draw_no_runnable;
 786     trace("OleCreate with OLERENDER_DRAW (no IOlObjectRunnable):\n");
 787     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
 788     ok_ole_success(hr, "OleCreate");
 789     IOleObject_Release(pObject);
 790     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 791
 792     runnable = &OleObjectRunnable;
 793     cache = NULL;
 794     expected_method_list = methods_olerender_draw_no_cache;
 795     trace("OleCreate with OLERENDER_DRAW (no IOlObjectRunnable):\n");
 796     hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, 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     trace("end\n");
 801 }
 802
 803 static void test_OleLoad(IStorage *pStorage)
 804 {
 805     HRESULT hr;
 806     IOleObject *pObject;
 807
 808     static const char *methods_oleload[] =
 809     {
 810         "OleObject_QueryInterface",
 811         "OleObject_AddRef",
 812         "OleObject_QueryInterface",
 813         "OleObject_AddRef",
 814         "OleObject_GetMiscStatus",
 815         "OleObject_QueryInterface",
 816         "OleObjectPersistStg_AddRef",
 817         "OleObjectPersistStg_Load",
 818         "OleObjectPersistStg_Release",
 819         "OleObject_SetClientSite",
 820         "OleObject_Release",
 821         "OleObject_QueryInterface",
 822         "OleObject_Release",
 823         NULL
 824     };
 825
 826     expected_method_list = methods_oleload;
 827     trace("OleLoad:\n");
 828     hr = OleLoad(pStorage, &IID_IOleObject, (IOleClientSite *)0xdeadbeef, (void **)&pObject);
 829     ok_ole_success(hr, "OleLoad");
 830     IOleObject_Release(pObject);
 831     ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 832 }
 833
 834 START_TEST(ole2)
 835 {
 836     DWORD dwRegister;
 837     IStorage *pStorage;
 838     STATSTG statstg;
 839     HRESULT hr;
 840
 841     CoInitialize(NULL);
 842
 843     hr = CoRegisterClassObject(&CLSID_Equation3, (IUnknown *)&OleObjectCF, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
 844     ok_ole_success(hr, "CoRegisterClassObject");
 845
 846     hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
 847     ok_ole_success(hr, "StgCreateDocfile");
 848
 849     test_OleCreate(pStorage);
 850
 851     hr = IStorage_Stat(pStorage, &statstg, STATFLAG_NONAME);
 852     ok_ole_success(hr, "IStorage_Stat");
 853     ok(IsEqualCLSID(&CLSID_Equation3, &statstg.clsid), "Wrong CLSID in storage\n");
 854
 855     test_OleLoad(pStorage);
 856
 857     IStorage_Release(pStorage);
 858
 859     hr = CoRevokeClassObject(dwRegister);
 860     ok_ole_success(hr, "CoRevokeClassObject");
 861
 862     CoUninitialize();
 863 }