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