ole2.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "objbase.h"
#include "shlguid.h"
#include "wine/test.h"

Include dependency graph for ole2.c:

Go to the source code of this file.

Classes
struct	expected_method
struct	PresentationDataHeader
struct	stream_def
struct	storage_def

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	WIN32_LEAN_AND_MEAN
#define	ok_ole_success(hr, func)   ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
#define	DEFINE_EXPECT(func)   static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
#define	SET_EXPECT(func)   expect_ ## func = TRUE
#define	CHECK_EXPECT2(func)
#define	CHECK_EXPECT(func)
#define	CHECK_CALLED(func)
#define	TEST_OPTIONAL   0x1
#define	TEST_TODO   0x2
#define	CHECK_EXPECTED_METHOD(method_name)   check_expected_method_fmt(method_name, NULL)
#define	CHECK_EXPECTED_METHOD_FMT(method_name, fmt)   check_expected_method_fmt(method_name, fmt)
#define	CHECK_NO_EXTRA_METHODS()
#define	MAX_STREAM   16
#define	MAX_FMTS   5

Typedefs
typedef struct PresentationDataHeader	PresentationDataHeader

Functions
	DEFINE_EXPECT (Storage_Stat)
	DEFINE_EXPECT (Storage_OpenStream_CompObj)
	DEFINE_EXPECT (Storage_OpenStream_OlePres)
	DEFINE_EXPECT (Storage_SetClass)
	DEFINE_EXPECT (Storage_CreateStream_CompObj)
	DEFINE_EXPECT (Storage_CreateStream_OlePres)
	DEFINE_EXPECT (Storage_OpenStream_Ole)
	DEFINE_EXPECT (Storage_DestroyElement)
static void	check_expected_method_fmt (const char *method_name, const FORMATETC *fmt)
static void	create_dib (STGMEDIUM *med)
static void	create_bitmap (STGMEDIUM *med)
static void	create_emf (STGMEDIUM *med)
static void	create_mfpict (STGMEDIUM *med)
static void	create_text (STGMEDIUM *med)
static HRESULT WINAPI	OleObject_QueryInterface (IOleObject *iface, REFIID riid, void **ppv)
static ULONG WINAPI	OleObject_AddRef (IOleObject *iface)
static ULONG WINAPI	OleObject_Release (IOleObject *iface)
static HRESULT WINAPI	OleObject_SetClientSite (IOleObject *iface, IOleClientSite *pClientSite)
static HRESULT WINAPI	OleObject_GetClientSite (IOleObject *iface, IOleClientSite **ppClientSite)
static HRESULT WINAPI	OleObject_SetHostNames (IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
static HRESULT WINAPI	OleObject_Close (IOleObject *iface, DWORD dwSaveOption)
static HRESULT WINAPI	OleObject_SetMoniker (IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
static HRESULT WINAPI	OleObject_GetMoniker (IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
static HRESULT WINAPI	OleObject_InitFromData (IOleObject *iface, IDataObject *pDataObject, BOOL fCreation, DWORD dwReserved)
static HRESULT WINAPI	OleObject_GetClipboardData (IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
static HRESULT WINAPI	OleObject_DoVerb (IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
static HRESULT WINAPI	OleObject_EnumVerbs (IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
static HRESULT WINAPI	OleObject_Update (IOleObject *iface)
static HRESULT WINAPI	OleObject_IsUpToDate (IOleObject *iface)
static HRESULT WINAPI	OleObject_GetUserClassID (IOleObject *iface, CLSID *pClsid)
static HRESULT WINAPI	OleObject_GetUserType (IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
static HRESULT WINAPI	OleObject_SetExtent (IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
static HRESULT WINAPI	OleObject_GetExtent (IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
static HRESULT WINAPI	OleObject_Advise (IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
static HRESULT WINAPI	OleObject_Unadvise (IOleObject *iface, DWORD dwConnection)
static HRESULT WINAPI	OleObject_EnumAdvise (IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
static HRESULT WINAPI	OleObject_GetMiscStatus (IOleObject *iface, DWORD aspect, DWORD *pdwStatus)
static HRESULT WINAPI	OleObject_SetColorScheme (IOleObject *iface, LOGPALETTE *pLogpal)
static HRESULT WINAPI	OleObjectPersistStg_QueryInterface (IPersistStorage *iface, REFIID riid, void **ppv)
static ULONG WINAPI	OleObjectPersistStg_AddRef (IPersistStorage *iface)
static ULONG WINAPI	OleObjectPersistStg_Release (IPersistStorage *iface)
static HRESULT WINAPI	OleObjectPersistStg_GetClassId (IPersistStorage *iface, CLSID *clsid)
static HRESULT WINAPI	OleObjectPersistStg_IsDirty (IPersistStorage *iface)
static HRESULT WINAPI	OleObjectPersistStg_InitNew (IPersistStorage *iface, IStorage *pStg)
static HRESULT WINAPI	OleObjectPersistStg_Load (IPersistStorage *iface, IStorage *pStg)
static HRESULT WINAPI	OleObjectPersistStg_Save (IPersistStorage *iface, IStorage *pStgSave, BOOL fSameAsLoad)
static HRESULT WINAPI	OleObjectPersistStg_SaveCompleted (IPersistStorage *iface, IStorage *pStgNew)
static HRESULT WINAPI	OleObjectPersistStg_HandsOffStorage (IPersistStorage *iface)
static HRESULT WINAPI	OleObjectCache_QueryInterface (IOleCache *iface, REFIID riid, void **ppv)
static ULONG WINAPI	OleObjectCache_AddRef (IOleCache *iface)
static ULONG WINAPI	OleObjectCache_Release (IOleCache *iface)
static HRESULT WINAPI	OleObjectCache_Cache (IOleCache *iface, FORMATETC *pformatetc, DWORD advf, DWORD *pdwConnection)
static HRESULT WINAPI	OleObjectCache_Uncache (IOleCache *iface, DWORD dwConnection)
static HRESULT WINAPI	OleObjectCache_EnumCache (IOleCache *iface, IEnumSTATDATA **ppenumSTATDATA)
static HRESULT WINAPI	OleObjectCache_InitCache (IOleCache *iface, IDataObject *pDataObject)
static HRESULT WINAPI	OleObjectCache_SetData (IOleCache *iface, FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
static HRESULT WINAPI	OleObjectCF_QueryInterface (IClassFactory *iface, REFIID riid, void **ppv)
static ULONG WINAPI	OleObjectCF_AddRef (IClassFactory *iface)
static ULONG WINAPI	OleObjectCF_Release (IClassFactory *iface)
static HRESULT WINAPI	OleObjectCF_CreateInstance (IClassFactory *iface, IUnknown *punkOuter, REFIID riid, void **ppv)
static HRESULT WINAPI	OleObjectCF_LockServer (IClassFactory *iface, BOOL lock)
static HRESULT WINAPI	OleObjectRunnable_QueryInterface (IRunnableObject *iface, REFIID riid, void **ppv)
static ULONG WINAPI	OleObjectRunnable_AddRef (IRunnableObject *iface)
static ULONG WINAPI	OleObjectRunnable_Release (IRunnableObject *iface)
static HRESULT WINAPI	OleObjectRunnable_GetRunningClass (IRunnableObject *iface, LPCLSID lpClsid)
static HRESULT WINAPI	OleObjectRunnable_Run (IRunnableObject *iface, LPBINDCTX pbc)
static BOOL WINAPI	OleObjectRunnable_IsRunning (IRunnableObject *iface)
static HRESULT WINAPI	OleObjectRunnable_LockRunning (IRunnableObject *iface, BOOL fLock, BOOL fLastUnlockCloses)
static HRESULT WINAPI	OleObjectRunnable_SetContainedObject (IRunnableObject *iface, BOOL fContained)
static HRESULT WINAPI	viewobject_QueryInterface (IViewObject *iface, REFIID riid, void **obj)
static ULONG WINAPI	viewobject_AddRef (IViewObject *iface)
static ULONG WINAPI	viewobject_Release (IViewObject *iface)
static HRESULT WINAPI	viewobject_Draw (IViewObject *iface, DWORD aspect, LONG index, void *paspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL bounds, LPCRECTL wbounds, BOOL(STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue)
static HRESULT WINAPI	viewobject_GetColorSet (IViewObject *iface, DWORD draw_aspect, LONG index, void *aspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **colorset)
static HRESULT WINAPI	viewobject_Freeze (IViewObject *iface, DWORD draw_aspect, LONG index, void *aspect, DWORD *freeze)
static HRESULT WINAPI	viewobject_Unfreeze (IViewObject *iface, DWORD freeze)
static HRESULT WINAPI	viewobject_SetAdvise (IViewObject *iface, DWORD aspects, DWORD advf, IAdviseSink *sink)
static HRESULT WINAPI	viewobject_GetAdvise (IViewObject *iface, DWORD *aspects, DWORD *advf, IAdviseSink **sink)
static void	test_OleCreate (IStorage *pStorage)
static void	test_OleLoad (IStorage *pStorage)
static BOOL STDMETHODCALLTYPE	draw_continue (ULONG_PTR param)
static BOOL STDMETHODCALLTYPE	draw_continue_false (ULONG_PTR param)
static HRESULT WINAPI	AdviseSink_QueryInterface (IAdviseSink *iface, REFIID riid, void **ppv)
static ULONG WINAPI	AdviseSink_AddRef (IAdviseSink *iface)
static ULONG WINAPI	AdviseSink_Release (IAdviseSink *iface)
static void WINAPI	AdviseSink_OnDataChange (IAdviseSink *iface, FORMATETC *pFormatetc, STGMEDIUM *pStgmed)
static void WINAPI	AdviseSink_OnViewChange (IAdviseSink *iface, DWORD dwAspect, LONG lindex)
static void WINAPI	AdviseSink_OnRename (IAdviseSink *iface, IMoniker *pmk)
static void WINAPI	AdviseSink_OnSave (IAdviseSink *iface)
static void WINAPI	AdviseSink_OnClose (IAdviseSink *iface)
static HRESULT WINAPI	DataObject_QueryInterface (IDataObject *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataObject_AddRef (IDataObject *iface)
static ULONG WINAPI	DataObject_Release (IDataObject *iface)
static BOOL	fmtetc_equal (const FORMATETC *a, const FORMATETC *b)
static HRESULT WINAPI	DataObject_GetData (IDataObject *iface, FORMATETC *fmt_in, STGMEDIUM *med)
static HRESULT WINAPI	DataObject_GetDataHere (IDataObject *iface, LPFORMATETC pformatetc, STGMEDIUM *pmedium)
static HRESULT WINAPI	DataObject_QueryGetData (IDataObject *iface, FORMATETC *fmt_in)
static HRESULT WINAPI	DataObject_GetCanonicalFormatEtc (IDataObject *iface, LPFORMATETC pformatectIn, LPFORMATETC pformatetcOut)
static HRESULT WINAPI	DataObject_SetData (IDataObject *iface, LPFORMATETC pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
static HRESULT WINAPI	DataObject_EnumFormatEtc (IDataObject *iface, DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
static HRESULT WINAPI	DataObject_DAdvise (IDataObject *iface, FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
static HRESULT WINAPI	DataObject_DUnadvise (IDataObject *iface, DWORD dwConnection)
static HRESULT WINAPI	DataObject_EnumDAdvise (IDataObject *iface, IEnumSTATDATA **ppenumAdvise)
static HRESULT WINAPI	Unknown_QueryInterface (IUnknown *iface, REFIID riid, void **ppv)
static ULONG WINAPI	Unknown_AddRef (IUnknown *iface)
static ULONG WINAPI	Unknown_Release (IUnknown *iface)
static void	check_enum_cache (IOleCache2 *cache, const STATDATA *expect, int num)
static void	test_data_cache (void)
static IStorage *	create_storage (int num)
static void	test_data_cache_dib_contents_stream (int num)
static void	check_bitmap_size (HBITMAP h, int cx, int cy)
static void	check_dib_size (HGLOBAL h, int cx, int cy)
static void	test_data_cache_cache (void)
static void	test_data_cache_init (void)
static void	test_data_cache_initnew (void)
static void	test_data_cache_updatecache (void)
static void	test_default_handler (void)
static void	test_runnable (void)
static HRESULT WINAPI	OleRun_QueryInterface (IRunnableObject *iface, REFIID riid, void **ppv)
static ULONG WINAPI	OleRun_AddRef (IRunnableObject *iface)
static ULONG WINAPI	OleRun_Release (IRunnableObject *iface)
static HRESULT WINAPI	OleRun_GetRunningClass (IRunnableObject *iface, CLSID *clsid)
static HRESULT WINAPI	OleRun_Run (IRunnableObject *iface, LPBINDCTX ctx)
static BOOL WINAPI	OleRun_IsRunning (IRunnableObject *iface)
static HRESULT WINAPI	OleRun_LockRunning (IRunnableObject *iface, BOOL lock, BOOL last_unlock_closes)
static HRESULT WINAPI	OleRun_SetContainedObject (IRunnableObject *iface, BOOL contained)
static void	test_OleRun (void)
static void	test_OleLockRunning (void)
static void	test_OleDraw (void)
static HRESULT WINAPI	Storage_QueryInterface (IStorage *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	Storage_AddRef (IStorage *iface)
static ULONG WINAPI	Storage_Release (IStorage *iface)
static HRESULT WINAPI	Storage_CreateStream (IStorage *iface, LPCOLESTR pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStream **ppstm)
static HRESULT WINAPI	Storage_OpenStream (IStorage *iface, LPCOLESTR pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm)
static HRESULT WINAPI	Storage_CreateStorage (IStorage *iface, LPCOLESTR pwcsName, DWORD grfMode, DWORD dwStgFmt, DWORD reserved2, IStorage **ppstg)
static HRESULT WINAPI	Storage_OpenStorage (IStorage *iface, LPCOLESTR pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg)
static HRESULT WINAPI	Storage_CopyTo (IStorage *iface, DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest)
static HRESULT WINAPI	Storage_MoveElementTo (IStorage *iface, LPCOLESTR pwcsName, IStorage *pstgDest, LPCOLESTR pwcsNewName, DWORD grfFlags)
static HRESULT WINAPI	Storage_Commit (IStorage *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	Storage_Revert (IStorage *iface)
static HRESULT WINAPI	Storage_EnumElements (IStorage *iface, DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum)
static HRESULT WINAPI	Storage_DestroyElement (IStorage *iface, LPCOLESTR pwcsName)
static HRESULT WINAPI	Storage_RenameElement (IStorage *iface, LPCOLESTR pwcsOldName, LPCOLESTR pwcsNewName)
static HRESULT WINAPI	Storage_SetElementTimes (IStorage *iface, LPCOLESTR pwcsName, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime)
static HRESULT WINAPI	Storage_SetClass (IStorage *iface, REFCLSID clsid)
static HRESULT WINAPI	Storage_SetStateBits (IStorage *iface, DWORD grfStateBits, DWORD grfMask)
static HRESULT WINAPI	Storage_Stat (IStorage *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static void	test_OleDoAutoConvert (void)
static void	test_data_cache_save (void)
static int	read_clipformat (IStream *stream)
static void	check_storage_contents (IStorage *stg, const struct storage_def *stg_def, int *enumerated_streams, int *matched_streams)
static HRESULT	stgmedium_cmp (const STGMEDIUM *med1, STGMEDIUM *med2)
static IStorage *	create_storage_from_def (const struct storage_def *stg_def)
static void	get_stgdef (struct storage_def *stg_def, CLIPFORMAT cf, STGMEDIUM *stg_med, int stm_idx)
static void	get_stgmedium (CLIPFORMAT cfFormat, STGMEDIUM *stgmedium)
static void	test_data_cache_save_data (void)
static void	test_data_cache_contents (void)
static void	test_OleCreateStaticFromData (void)
	START_TEST (ole2)

Variables
static const CLSID *	Storage_SetClass_CLSID
static int	Storage_DestroyElement_limit
static IPersistStorage	OleObjectPersistStg = { &OleObjectPersistStgVtbl }
static IOleCache *	cache
static IRunnableObject *	runnable
static const CLSID	CLSID_WineTestOld
static const CLSID	CLSID_WineTest
static const IID	IID_WineTest
static const struct expected_method *	expected_method_list
static FORMATETC *	g_expected_fetc = NULL
static BOOL	g_showRunnable = TRUE
static BOOL	g_isRunning = TRUE
static HRESULT	g_GetMiscStatusFailsWith = S_OK
static HRESULT	g_QIFailsWith
static UINT	cf_test_1
static UINT	cf_test_2
static UINT	cf_test_3
static FORMATETC *	g_dataobject_fmts
static const BYTE	dib []
static const IOleObjectVtbl	OleObjectVtbl
static IOleObject	OleObject = { &OleObjectVtbl }
static const IPersistStorageVtbl	OleObjectPersistStgVtbl
static const IOleCacheVtbl	OleObjectCacheVtbl
static IOleCache	OleObjectCache = { &OleObjectCacheVtbl }
static const IClassFactoryVtbl	OleObjectCFVtbl
static IClassFactory	OleObjectCF = { &OleObjectCFVtbl }
static const IRunnableObjectVtbl	OleObjectRunnableVtbl
static IRunnableObject	OleObjectRunnable = { &OleObjectRunnableVtbl }
static const CLSID	CLSID_Equation3 = {0x0002CE02, 0x0000, 0x0000, {0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46} }
static const struct IViewObjectVtbl	viewobjectvtbl
static IViewObject	viewobject = { &viewobjectvtbl }
static const IAdviseSinkVtbl	AdviseSinkVtbl
static IAdviseSink	AdviseSink = { &AdviseSinkVtbl }
static IDataObjectVtbl	DataObjectVtbl
static IDataObject	DataObject = { &DataObjectVtbl }
static const IUnknownVtbl	UnknownVtbl
static IUnknown	unknown = { &UnknownVtbl }
static const WCHAR	CONTENTS [] = {'C','O','N','T','E','N','T','S',0}
static BYTE	file_dib []
static const IRunnableObjectVtbl	oleruntestvtbl
static IRunnableObject	testrunnable = { &oleruntestvtbl }
static const WCHAR	olepres0W [] = {2,'O','l','e','P','r','e','s','0','0','0',0}
static const WCHAR	comp_objW [] = {1,'C','o','m','p','O','b','j',0}
static IStream *	comp_obj_stream
static IStream *	ole_stream
static IStream *	olepres_stream
static IStream *	contents_stream
static IStorageVtbl	StorageVtbl
static IStorage	Storage = { &StorageVtbl }
static const unsigned char	bmpimage []
static const unsigned char	mf_blank_bits []
static const struct storage_def	stg_def_0
static const struct storage_def	stg_def_0_saved
static const struct storage_def	stg_def_1
static const struct storage_def	stg_def_1_saved
static const struct storage_def	stg_def_2
static const struct storage_def	stg_def_2_saved
static const struct storage_def	stg_def_3
static const struct storage_def	stg_def_3_saved
static const struct storage_def	stg_def_4
static const struct storage_def	stg_def_4_saved
static const struct storage_def	stg_def_5
static const struct storage_def	stg_def_5_saved
static const struct storage_def	stg_def_6
static const struct storage_def	stg_def_6_saved
static const struct storage_def	stg_def_7
static const struct storage_def	stg_def_7_saved
static const struct storage_def	stg_def_8
static const struct storage_def	stg_def_8_saved
static const struct storage_def	stg_def_9
static const struct storage_def	stg_def_9_saved
static const BYTE	dib_inf []
static const BYTE	mf_rec []

Macro Definition Documentation

CHECK_CALLED

#define CHECK_CALLED

(

func

)

Value:

do { \
        ok(called_ ## func, "expected " #func "\n"); \
        expect_ ## func = called_ ## func = FALSE; \
    }while(0)

Definition at line 56 of file ole2.c.

CHECK_EXPECT

#define CHECK_EXPECT

(

func

)

Value:

do { \
        CHECK_EXPECT2(func); \
        expect_ ## func = FALSE; \
    }while(0)

Definition at line 50 of file ole2.c.

CHECK_EXPECT2

#define CHECK_EXPECT2

(

func

)

Value:

do { \
        ok(expect_ ##func, "unexpected call " #func "\n"); \
        called_ ## func = TRUE; \
    }while(0)

Definition at line 44 of file ole2.c.

CHECK_EXPECTED_METHOD

#define CHECK_EXPECTED_METHOD

(

method_name

)

check_expected_method_fmt(method_name, NULL)

Definition at line 190 of file ole2.c.

CHECK_EXPECTED_METHOD_FMT

#define CHECK_EXPECTED_METHOD_FMT	(		method_name,
			fmt
	)		check_expected_method_fmt(method_name, fmt)

Definition at line 191 of file ole2.c.

CHECK_NO_EXTRA_METHODS

#define CHECK_NO_EXTRA_METHODS

(

)

Value:

do { \
        while (expected_method_list->flags & TEST_OPTIONAL) \
            expected_method_list++; \
        ok(!expected_method_list->method, "Method sequence starting from %s not called\n", expected_method_list->method); \
    } while (0)

Definition at line 193 of file ole2.c.

COBJMACROS

#define COBJMACROS

Definition at line 22 of file ole2.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 23 of file ole2.c.

DEFINE_EXPECT

#define DEFINE_EXPECT

(

func

)

static BOOL expect_ ## func = FALSE, called_ ## func = FALSE

Definition at line 38 of file ole2.c.

MAX_FMTS

#define MAX_FMTS   5

Definition at line 4342 of file ole2.c.

MAX_STREAM

#define MAX_STREAM   16

Definition at line 3835 of file ole2.c.

ok_ole_success

#define ok_ole_success	(		hr,
			func
	)		ok(hr == S_OK, func " failed with error 0x%08x\n", hr)

Definition at line 36 of file ole2.c.

SET_EXPECT

#define SET_EXPECT

(

func

)

expect_ ## func = TRUE

Definition at line 41 of file ole2.c.

TEST_OPTIONAL

#define TEST_OPTIONAL   0x1

Definition at line 102 of file ole2.c.

TEST_TODO

#define TEST_TODO   0x2

Definition at line 103 of file ole2.c.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 24 of file ole2.c.

Typedef Documentation

PresentationDataHeader

typedef struct PresentationDataHeader PresentationDataHeader

Function Documentation

AdviseSink_AddRef()

static ULONG WINAPI AdviseSink_AddRef ( IAdviseSink *  iface )

static

Definition at line 1391 of file ole2.c.

{
    return 2;
}

AdviseSink_OnClose()

static void WINAPI AdviseSink_OnClose ( IAdviseSink *  iface )

static

Definition at line 1430 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("AdviseSink_OnClose");
}

AdviseSink_OnDataChange()

static void WINAPI AdviseSink_OnDataChange ( IAdviseSink *  iface, FORMATETC *  pFormatetc, STGMEDIUM *  pStgmed  )

static

Definition at line 1402 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("AdviseSink_OnDataChange");
}

AdviseSink_OnRename()

static void WINAPI AdviseSink_OnRename ( IAdviseSink *  iface, IMoniker *  pmk  )

static

Definition at line 1418 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("AdviseSink_OnRename");
}

AdviseSink_OnSave()

static void WINAPI AdviseSink_OnSave ( IAdviseSink *  iface )

static

Definition at line 1425 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("AdviseSink_OnSave");
}

AdviseSink_OnViewChange()

static void WINAPI AdviseSink_OnViewChange ( IAdviseSink *  iface, DWORD  dwAspect, LONG  lindex  )

static

Definition at line 1410 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("AdviseSink_OnViewChange");
}

AdviseSink_QueryInterface()

static HRESULT WINAPI AdviseSink_QueryInterface ( IAdviseSink *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1379 of file ole2.c.

{
    if (IsEqualIID(riid, &IID_IAdviseSink) || IsEqualIID(riid, &IID_IUnknown))
    {
        *ppv = iface;
        IAdviseSink_AddRef(iface);
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

AdviseSink_Release()

static ULONG WINAPI AdviseSink_Release ( IAdviseSink *  iface )

static

Definition at line 1396 of file ole2.c.

{
    return 1;
}

check_bitmap_size()

static void check_bitmap_size ( HBITMAP  h, int  cx, int  cy  )

static

Definition at line 2213 of file ole2.c.

{
    BITMAP bm;

    GetObjectW( h, sizeof(bm), &bm );
    ok( bm.bmWidth == cx, "got %d expect %d\n", bm.bmWidth, cx );
    ok( bm.bmHeight == cy, "got %d expect %d\n", bm.bmHeight, cy );
}

Referenced by test_data_cache_cache().

check_dib_size()

static void check_dib_size ( HGLOBAL  h, int  cx, int  cy  )

static

Definition at line 2222 of file ole2.c.

{
    BITMAPINFO *info;

    info = GlobalLock( h );
    ok( info->bmiHeader.biWidth == cx, "got %d expect %d\n", info->bmiHeader.biWidth, cx );
    ok( info->bmiHeader.biHeight == cy, "got %d expect %d\n", info->bmiHeader.biHeight, cy );
    GlobalUnlock( h );
}

Referenced by test_data_cache_cache().

check_enum_cache()

static void check_enum_cache ( IOleCache2 *  cache, const STATDATA *  expect, int  num  )

static

Definition at line 1659 of file ole2.c.

{
    IEnumSTATDATA *enum_stat;
    STATDATA stat;
    HRESULT hr;

    hr = IOleCache2_EnumCache( cache, &enum_stat );
    ok( hr == S_OK, "got %08x\n", hr );

    while (IEnumSTATDATA_Next(enum_stat, 1, &stat, NULL) == S_OK)
    {
        ok( stat.formatetc.cfFormat == expect->formatetc.cfFormat, "got %d expect %d\n",
            stat.formatetc.cfFormat, expect->formatetc.cfFormat );
        ok( !stat.formatetc.ptd == !expect->formatetc.ptd, "got %p expect %p\n",
            stat.formatetc.ptd, expect->formatetc.ptd );
        ok( stat.formatetc.dwAspect == expect->formatetc.dwAspect, "got %d expect %d\n",
            stat.formatetc.dwAspect, expect->formatetc.dwAspect );
        ok( stat.formatetc.lindex == expect->formatetc.lindex, "got %d expect %d\n",
            stat.formatetc.lindex, expect->formatetc.lindex );
        ok( stat.formatetc.tymed == expect->formatetc.tymed, "got %d expect %d\n",
            stat.formatetc.tymed, expect->formatetc.tymed );
        ok( stat.advf == expect->advf, "got %d expect %d\n", stat.advf, expect->advf );
        ok( stat.pAdvSink == 0, "got %p\n", stat.pAdvSink );
        ok( stat.dwConnection == expect->dwConnection, "got %d expect %d\n", stat.dwConnection, expect->dwConnection );
        num--;
        expect++;
    }

    ok( num == 0, "incorrect number. num %d\n", num );

    IEnumSTATDATA_Release( enum_stat );
}

Referenced by test_data_cache_cache(), test_data_cache_dib_contents_stream(), test_data_cache_init(), test_data_cache_initnew(), and test_data_cache_updatecache().

check_expected_method_fmt()

static void check_expected_method_fmt ( const char *  method_name, const FORMATETC *  fmt  )

inlinestatic

Definition at line 154 of file ole2.c.

{
    trace("%s\n", method_name);
    ok(expected_method_list->method != NULL, "Extra method %s called\n", method_name);
    if (!strcmp(expected_method_list->method, "WINE_EXTRA"))
    {
        todo_wine ok(0, "Too many method calls.\n");
        return;
    }
    if (expected_method_list->method)
    {
        while (expected_method_list->flags & TEST_OPTIONAL &&
               strcmp(expected_method_list->method, method_name) != 0)
            expected_method_list++;
        todo_wine_if (expected_method_list->flags & TEST_TODO)
        {
            ok(!strcmp(expected_method_list->method, method_name),
               "Expected %s to be called instead of %s\n",
               expected_method_list->method, method_name);
            if (fmt)
            {
                ok(fmt->cfFormat == expected_method_list->fmt.cfFormat, "got cf %04x vs %04x\n",
                   fmt->cfFormat, expected_method_list->fmt.cfFormat );
                ok(fmt->dwAspect == expected_method_list->fmt.dwAspect, "got aspect %d vs %d\n",
                   fmt->dwAspect, expected_method_list->fmt.dwAspect );
                ok(fmt->lindex == expected_method_list->fmt.lindex, "got lindex %d vs %d\n",
                   fmt->lindex, expected_method_list->fmt.lindex );
                ok(fmt->tymed == expected_method_list->fmt.tymed, "got tymed %d vs %d\n",
                   fmt->tymed, expected_method_list->fmt.tymed );
            }
        }
        expected_method_list++;
    }
}

check_storage_contents()

static void check_storage_contents ( IStorage *  stg, const struct storage_def *  stg_def, int *  enumerated_streams, int *  matched_streams  )

static

Definition at line 3994 of file ole2.c.

{
    HRESULT hr;
    IEnumSTATSTG *enumstg;
    IStream *stream;
    STATSTG stat;
    int i, seen_stream[MAX_STREAM] = { 0 };

    if (winetest_debug > 1)
        trace("check_storage_contents:\n=============================================\n");

    *enumerated_streams = 0;
    *matched_streams = 0;

    hr = IStorage_Stat(stg, &stat, STATFLAG_NONAME);
    ok(hr == S_OK, "unexpected %#x\n", hr);
    ok(IsEqualCLSID(stg_def->clsid, &stat.clsid), "expected %s, got %s\n",
       wine_dbgstr_guid(stg_def->clsid), wine_dbgstr_guid(&stat.clsid));

    hr = IStorage_EnumElements(stg, 0, NULL, 0, &enumstg);
    ok(hr == S_OK, "unexpected %#x\n", hr);

    for (;;)
    {
        ULONG bytes;
        int clipformat = -1;
        PresentationDataHeader header;
        char name[32];
        BYTE data[1024];

        memset(&header, 0, sizeof(header));

        hr = IEnumSTATSTG_Next(enumstg, 1, &stat, NULL);
        if(hr == S_FALSE) break;
        ok(hr == S_OK, "unexpected %#x\n", hr);

        if (winetest_debug > 1)
            trace("name %s, type %u, size %d, clsid %s\n",
                wine_dbgstr_w(stat.pwcsName), stat.type, stat.cbSize.u.LowPart, wine_dbgstr_guid(&stat.clsid));

        ok(stat.type == STGTY_STREAM, "unexpected %#x\n", stat.type);

        WideCharToMultiByte(CP_ACP, 0, stat.pwcsName, -1, name, sizeof(name), NULL, NULL);

        hr = IStorage_OpenStream(stg, stat.pwcsName, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
        ok(hr == S_OK, "unexpected %#x\n", hr);

        if (!memcmp(name, "\2OlePres", 8))
        {
            ULONG header_size = sizeof(header);

            clipformat = read_clipformat(stream);

            if (clipformat == 0) /* view cache */
                header_size = FIELD_OFFSET(PresentationDataHeader, unknown7);

            hr = IStream_Read(stream, &header, header_size, &bytes);
            ok(hr == S_OK, "unexpected %#x\n", hr);
            ok(bytes == header_size, "read %u bytes, expected %u\n", bytes, header_size);

            if (winetest_debug > 1)
                trace("header: tdSize %#x, dvAspect %#x, lindex %#x, advf %#x, unknown7 %#x, dwObjectExtentX %#x, dwObjectExtentY %#x, dwSize %#x\n",
                    header.tdSize, header.dvAspect, header.lindex, header.advf, header.unknown7,
                    header.dwObjectExtentX, header.dwObjectExtentY, header.dwSize);
        }

        memset(data, 0, sizeof(data));
        hr = IStream_Read(stream, data, sizeof(data), &bytes);
        ok(hr == S_OK, "unexpected %#x\n", hr);
        if (winetest_debug > 1)
            trace("stream data (%u bytes): %02x %02x %02x %02x\n", bytes, data[0], data[1], data[2], data[3]);

        for (i = 0; i < stg_def->stream_count; i++)
        {
            if (seen_stream[i]) continue;

            if (winetest_debug > 1)
                trace("%s/%s, %d/%d, %d/%d, %d/%d\n",
                    stg_def->stream[i].name, name,
                    stg_def->stream[i].cf, clipformat,
                    stg_def->stream[i].dvAspect, header.dvAspect,
                    stg_def->stream[i].advf, header.advf);

            if (!strcmp(stg_def->stream[i].name, name) &&
                stg_def->stream[i].cf == clipformat &&
                stg_def->stream[i].dvAspect == header.dvAspect &&
                stg_def->stream[i].advf == header.advf &&
                stg_def->stream[i].data_size <= bytes &&
                (!stg_def->stream[i].data_size ||
                    (!memcmp(stg_def->stream[i].data, data, min(stg_def->stream[i].data_size, bytes)))))
            {
                if (winetest_debug > 1)
                    trace("stream %d matches def stream %d\n", *enumerated_streams, i);
                seen_stream[i] = 1;
                *matched_streams += 1;
            }
        }

        CoTaskMemFree(stat.pwcsName);
        IStream_Release(stream);

        *enumerated_streams += 1;
    }

    IEnumSTATSTG_Release(enumstg);
}

Referenced by test_data_cache_contents(), test_data_cache_save_data(), and test_OleCreateStaticFromData().

create_bitmap()

static void create_bitmap ( STGMEDIUM *  med )

static

Definition at line 223 of file ole2.c.

{
    med->tymed = TYMED_GDI;
    U(med)->hBitmap = CreateBitmap( 1, 1, 1, 1, NULL );
    med->pUnkForRelease = NULL;
}

Referenced by DataObject_GetData(), and test_data_cache_cache().

create_dib()

static void create_dib ( STGMEDIUM *  med )

static

Definition at line 211 of file ole2.c.

{
    void *ptr;

    med->tymed = TYMED_HGLOBAL;
    U(med)->hGlobal = GlobalAlloc( GMEM_MOVEABLE, sizeof(dib) );
    ptr = GlobalLock( U(med)->hGlobal );
    memcpy( ptr, dib, sizeof(dib) );
    GlobalUnlock( U(med)->hGlobal );
    med->pUnkForRelease = NULL;
}

Referenced by DataObject_GetData(), get_stgmedium(), test_data_cache_cache(), and wined3d_texture_update_desc().

create_emf()

static void create_emf ( STGMEDIUM *  med )

static

Definition at line 230 of file ole2.c.

{
    HDC hdc = CreateEnhMetaFileW(NULL, NULL, NULL, NULL);

    Rectangle(hdc, 0, 0, 150, 300);
    med->tymed = TYMED_ENHMF;
    U(med)->hEnhMetaFile = CloseEnhMetaFile(hdc);
    med->pUnkForRelease = NULL;
}

Referenced by DataObject_GetData(), and get_stgmedium().

create_mfpict()

static void create_mfpict ( STGMEDIUM *  med )

static

Definition at line 240 of file ole2.c.

{
    METAFILEPICT *mf;
    HDC hdc = CreateMetaFileW(NULL);

    Rectangle(hdc, 0, 0, 100, 200);

    med->tymed = TYMED_MFPICT;
    U(med)->hMetaFilePict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
    mf = GlobalLock(U(med)->hMetaFilePict);
    mf->mm = MM_ANISOTROPIC;
    mf->xExt = 100;
    mf->yExt = 200;
    mf->hMF = CloseMetaFile(hdc);
    GlobalUnlock(U(med)->hMetaFilePict);
    med->pUnkForRelease = NULL;
}

Referenced by get_stgmedium().

create_storage()

static IStorage* create_storage ( int  num )

static

Definition at line 2099 of file ole2.c.

{
    IStorage *stg;
    IStream *stm;
    HRESULT hr;
    ULONG written;

    hr = StgCreateDocfile( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_DELETEONRELEASE, 0, &stg );
    ok( hr == S_OK, "got %08x\n", hr);
    hr = IStorage_SetClass( stg, &CLSID_Picture_Dib );
    ok( hr == S_OK, "got %08x\n", hr);
    hr = IStorage_CreateStream( stg, CONTENTS, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &stm );
    ok( hr == S_OK, "got %08x\n", hr);
    if (num == 1) /* Set biXPelsPerMeter = 0 */
    {
        file_dib[0x26] = 0;
        file_dib[0x27] = 0;
    }
    hr = IStream_Write( stm, file_dib, sizeof(file_dib), &written );
    ok( hr == S_OK, "got %08x\n", hr);
    IStream_Release( stm );
    return stg;
}

Referenced by test_data_cache_dib_contents_stream().

create_storage_from_def()

static IStorage* create_storage_from_def ( const struct storage_def *  stg_def )

static

Definition at line 4179 of file ole2.c.

{
    HRESULT hr;
    IStorage *stg;
    IStream *stm;
    int i;

    hr = StgCreateDocfile(NULL, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &stg);
    ok(hr == S_OK, "unexpected %#x\n", hr);

    hr = IStorage_SetClass(stg, stg_def->clsid);
    ok(hr == S_OK, "unexpected %#x\n", hr);

    for (i = 0; i < stg_def->stream_count; i++)
    {
        WCHAR name[32];

        MultiByteToWideChar(CP_ACP, 0, stg_def->stream[i].name, -1, name, 32);
        hr = IStorage_CreateStream(stg, name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
        ok(hr == S_OK, "unexpected %#x\n", hr);

        if (stg_def->stream[i].cf != -1)
        {
            int clipformat[2];
            PresentationDataHeader hdr;

            if (stg_def->stream[i].cf)
            {
                clipformat[0] = -1;
                clipformat[1] = stg_def->stream[i].cf;
                hr = IStream_Write(stm, clipformat, sizeof(clipformat), NULL);
            }
            else
            {
                clipformat[0] = 0;
                hr = IStream_Write(stm, &clipformat[0], sizeof(clipformat[0]), NULL);
            }
            ok(hr == S_OK, "unexpected %#x\n", hr);

            hdr.tdSize = sizeof(hdr.tdSize);
            hdr.dvAspect = stg_def->stream[i].dvAspect;
            hdr.lindex = -1;
            hdr.advf = stg_def->stream[i].advf;
            hdr.unknown7 = 0;
            hdr.dwObjectExtentX = 0;
            hdr.dwObjectExtentY = 0;
            hdr.dwSize = stg_def->stream[i].data_size;
            hr = IStream_Write(stm, &hdr, sizeof(hdr), NULL);
            ok(hr == S_OK, "unexpected %#x\n", hr);
        }

        if (stg_def->stream[i].data_size)
        {
            hr = IStream_Write(stm, stg_def->stream[i].data, stg_def->stream[i].data_size, NULL);
            ok(hr == S_OK, "unexpected %#x\n", hr);
        }

        IStream_Release(stm);
    }

    return stg;
}

Referenced by test_data_cache_contents().

create_text()

static void create_text ( STGMEDIUM *  med )

static

Definition at line 258 of file ole2.c.

{
    HGLOBAL handle;
    char *p;

    handle = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 5);
    p = GlobalLock(handle);
    strcpy(p, "test");
    GlobalUnlock(handle);

    med->tymed = TYMED_HGLOBAL;
    U(med)->hGlobal = handle;
    med->pUnkForRelease = NULL;
}

Referenced by DataObject_GetData().

DataObject_AddRef()

static ULONG WINAPI DataObject_AddRef ( IDataObject *  iface )

static

Definition at line 1465 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_AddRef");
    return 2;
}

DataObject_DAdvise()

static HRESULT WINAPI DataObject_DAdvise ( IDataObject *  iface, FORMATETC *  pformatetc, DWORD  advf, IAdviseSink *  pAdvSink, DWORD *  pdwConnection  )

static

Definition at line 1570 of file ole2.c.

{
    STGMEDIUM stgmedium;

    CHECK_EXPECTED_METHOD("DataObject_DAdvise");
    *pdwConnection = 1;

    if(advf & ADVF_PRIMEFIRST)
    {
        ok(pformatetc->cfFormat == cf_test_2, "got %04x\n", pformatetc->cfFormat);
        stgmedium.tymed = TYMED_HGLOBAL;
        U(stgmedium).hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, 4);
        stgmedium.pUnkForRelease = NULL;
        IAdviseSink_OnDataChange(pAdvSink, pformatetc, &stgmedium);
    }

    return S_OK;
}

DataObject_DUnadvise()

static HRESULT WINAPI DataObject_DUnadvise ( IDataObject *  iface, DWORD  dwConnection  )

static

Definition at line 1594 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_DUnadvise");
    return S_OK;
}

DataObject_EnumDAdvise()

static HRESULT WINAPI DataObject_EnumDAdvise ( IDataObject *  iface, IEnumSTATDATA **  ppenumAdvise  )

static

Definition at line 1602 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_EnumDAdvise");
    return OLE_E_ADVISENOTSUPPORTED;
}

DataObject_EnumFormatEtc()

static HRESULT WINAPI DataObject_EnumFormatEtc ( IDataObject *  iface, DWORD  dwDirection, IEnumFORMATETC **  ppenumFormatEtc  )

static

Definition at line 1561 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_EnumFormatEtc");
    return E_NOTIMPL;
}

DataObject_GetCanonicalFormatEtc()

static HRESULT WINAPI DataObject_GetCanonicalFormatEtc ( IDataObject *  iface, LPFORMATETC  pformatectIn, LPFORMATETC  pformatetcOut  )

static

Definition at line 1542 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_GetCanonicalFormatEtc");
    return E_NOTIMPL;
}

DataObject_GetData()

static HRESULT WINAPI DataObject_GetData ( IDataObject *  iface, FORMATETC *  fmt_in, STGMEDIUM *  med  )

static

Definition at line 1487 of file ole2.c.

{
    FORMATETC *fmt;

    CHECK_EXPECTED_METHOD_FMT("DataObject_GetData", fmt_in);

    for (fmt = g_dataobject_fmts; fmt && fmt->cfFormat != 0; fmt++)
    {
        if (fmtetc_equal( fmt_in, fmt ))
        {
            switch (fmt->cfFormat)
            {
            case CF_DIB:
                create_dib( med );
                return S_OK;
            case CF_BITMAP:
                create_bitmap( med );
                return S_OK;
            case CF_ENHMETAFILE:
                create_emf( med );
                return S_OK;
            case CF_TEXT:
                create_text( med );
                return S_OK;
            default:
                trace( "unhandled fmt %d\n", fmt->cfFormat );
            }
        }
    }

    return S_FALSE;
}

DataObject_GetDataHere()

static HRESULT WINAPI DataObject_GetDataHere ( IDataObject *  iface, LPFORMATETC  pformatetc, STGMEDIUM *  pmedium  )

static

Definition at line 1521 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_GetDataHere");
    return E_NOTIMPL;
}

DataObject_QueryGetData()

static HRESULT WINAPI DataObject_QueryGetData ( IDataObject *  iface, FORMATETC *  fmt_in  )

static

Definition at line 1530 of file ole2.c.

{
    FORMATETC *fmt;

    CHECK_EXPECTED_METHOD_FMT("DataObject_QueryGetData", fmt_in);

    for (fmt = g_dataobject_fmts; fmt && fmt->cfFormat != 0; fmt++)
        if (fmtetc_equal( fmt_in, fmt )) return S_OK;

    return S_FALSE;
}

DataObject_QueryInterface()

static HRESULT WINAPI DataObject_QueryInterface ( IDataObject *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1449 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_QueryInterface");

    if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
    {
        *ppvObject = iface;
        return S_OK;
    }
    *ppvObject = NULL;
    return S_OK;
}

DataObject_Release()

static ULONG WINAPI DataObject_Release ( IDataObject *  iface )

static

Definition at line 1472 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_Release");
    return 1;
}

DataObject_SetData()

static HRESULT WINAPI DataObject_SetData ( IDataObject *  iface, LPFORMATETC  pformatetc, STGMEDIUM *  pmedium, BOOL  fRelease  )

static

Definition at line 1551 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("DataObject_SetData");
    return E_NOTIMPL;
}

DEFINE_EXPECT() [1/8]

DEFINE_EXPECT

(

Storage_Stat

)

DEFINE_EXPECT() [2/8]

DEFINE_EXPECT

(

Storage_OpenStream_CompObj

)

DEFINE_EXPECT() [3/8]

DEFINE_EXPECT

(

Storage_OpenStream_OlePres

)

DEFINE_EXPECT() [4/8]

DEFINE_EXPECT

(

Storage_SetClass

)

DEFINE_EXPECT() [5/8]

DEFINE_EXPECT

(

Storage_CreateStream_CompObj

)

DEFINE_EXPECT() [6/8]

DEFINE_EXPECT

(

Storage_CreateStream_OlePres

)

DEFINE_EXPECT() [7/8]

DEFINE_EXPECT

(

Storage_OpenStream_Ole

)

DEFINE_EXPECT() [8/8]

DEFINE_EXPECT

(

Storage_DestroyElement

)

draw_continue()

static BOOL STDMETHODCALLTYPE draw_continue ( ULONG_PTR  param )

static

Definition at line 1367 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("draw_continue");
    return TRUE;
}

Referenced by test_data_cache().

draw_continue_false()

static BOOL STDMETHODCALLTYPE draw_continue_false ( ULONG_PTR  param )

static

Definition at line 1373 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("draw_continue_false");
    return FALSE;
}

Referenced by test_data_cache().

fmtetc_equal()

static BOOL fmtetc_equal ( const FORMATETC *  a, const FORMATETC *  b  )

inlinestatic

Definition at line 1479 of file ole2.c.

{
    /* FIXME ptd */
    return a->cfFormat == b->cfFormat && a->dwAspect == b->dwAspect &&
        a->lindex == b->lindex && a->tymed == b->tymed;

}

Referenced by DataObject_GetData(), and DataObject_QueryGetData().

get_stgdef()

static void get_stgdef ( struct storage_def *  stg_def, CLIPFORMAT  cf, STGMEDIUM *  stg_med, int  stm_idx  )

static

Definition at line 4255 of file ole2.c.

{
    BYTE *data;
    int data_size;
    METAFILEPICT *mfpict;
    HDC hdc;

    switch (cf)
    {
    case CF_DIB:
        data_size = sizeof(dib);
        if (!strcmp(stg_def->stream[stm_idx].name, "CONTENTS"))
        {
            data_size += sizeof(dib_inf);
            data = HeapAlloc(GetProcessHeap(), 0, data_size);
            memcpy(data, dib_inf, sizeof(dib_inf));
            memcpy(data + sizeof(dib_inf), dib, sizeof(dib));
        }
        else
        {
            data = HeapAlloc(GetProcessHeap(), 0, data_size);
            memcpy(data, dib, sizeof(dib));
        }
        stg_def->stream[stm_idx].data = data;
        stg_def->stream[stm_idx].data_size = data_size;
        break;
    case CF_METAFILEPICT:
        mfpict = GlobalLock(U(stg_med)->hMetaFilePict);
        data_size = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
        if (!strcmp(stg_def->stream[stm_idx].name, "CONTENTS"))
        {
            data = HeapAlloc(GetProcessHeap(), 0, data_size + sizeof(mf_rec));
            memcpy(data, mf_rec, sizeof(mf_rec));
            GetMetaFileBitsEx(mfpict->hMF, data_size, data + sizeof(mf_rec));
            data_size += sizeof(mf_rec);
        }
        else
        {
            data = HeapAlloc(GetProcessHeap(), 0, data_size);
            GetMetaFileBitsEx(mfpict->hMF, data_size, data);
        }
        GlobalUnlock(U(stg_med)->hMetaFilePict);
        stg_def->stream[stm_idx].data_size = data_size;
        stg_def->stream[stm_idx].data = data;
        break;
    case CF_ENHMETAFILE:
        if (!strcmp(stg_def->stream[stm_idx].name, "CONTENTS"))
        {
            data_size = GetEnhMetaFileBits(U(stg_med)->hEnhMetaFile, 0, NULL);
            data = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) + sizeof(ENHMETAHEADER) + data_size);
            *((DWORD *)data) = sizeof(ENHMETAHEADER);
            GetEnhMetaFileBits(U(stg_med)->hEnhMetaFile, data_size, data + sizeof(DWORD) + sizeof(ENHMETAHEADER));
            memcpy(data + sizeof(DWORD), data + sizeof(DWORD) + sizeof(ENHMETAHEADER), sizeof(ENHMETAHEADER));
            data_size += sizeof(DWORD) + sizeof(ENHMETAHEADER);
        }
        else
        {
            hdc = GetDC(NULL);
            data_size = GetWinMetaFileBits(U(stg_med)->hEnhMetaFile, 0, NULL, MM_ANISOTROPIC, hdc);
            data = HeapAlloc(GetProcessHeap(), 0, data_size);
            GetWinMetaFileBits(U(stg_med)->hEnhMetaFile, data_size, data, MM_ANISOTROPIC, hdc);
            ReleaseDC(NULL, hdc);
        }
        stg_def->stream[stm_idx].data_size = data_size;
        stg_def->stream[stm_idx].data = data;
        break;
    }
}

Referenced by test_data_cache_save_data(), and test_OleCreateStaticFromData().

get_stgmedium()

static void get_stgmedium ( CLIPFORMAT  cfFormat, STGMEDIUM *  stgmedium  )

static

Definition at line 4324 of file ole2.c.

{
    switch (cfFormat)
    {
    case CF_DIB:
        create_dib(stgmedium);
        break;
    case CF_METAFILEPICT:
        create_mfpict(stgmedium);
        break;
    case CF_ENHMETAFILE:
        create_emf(stgmedium);
        break;
    default:
        ok(0, "cf %x not implemented\n", cfFormat);
    }
}

Referenced by test_data_cache_save_data(), and test_OleCreateStaticFromData().

OleObject_AddRef()

static ULONG WINAPI OleObject_AddRef ( IOleObject *  iface )

static

Definition at line 299 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_AddRef");
    return 2;
}

OleObject_Advise()

static HRESULT WINAPI OleObject_Advise ( IOleObject *  iface, IAdviseSink *  pAdvSink, DWORD *  pdwConnection  )

static

Definition at line 485 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_Advise");
    return S_OK;
}

OleObject_Close()

static HRESULT WINAPI OleObject_Close ( IOleObject *  iface, DWORD  dwSaveOption  )

static

Definition at line 343 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_Close");
    return S_OK;
}

OleObject_DoVerb()

static HRESULT WINAPI OleObject_DoVerb ( IOleObject *  iface, LONG  iVerb, LPMSG  lpmsg, IOleClientSite *  pActiveSite, LONG  lindex, HWND  hwndParent, LPCRECT  lprcPosRect  )

static

Definition at line 399 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_DoVerb");
    return S_OK;
}

OleObject_EnumAdvise()

static HRESULT WINAPI OleObject_EnumAdvise ( IOleObject *  iface, IEnumSTATDATA **  ppenumAdvise  )

static

Definition at line 506 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_EnumAdvise");
    return E_NOTIMPL;
}

OleObject_EnumVerbs()

static HRESULT WINAPI OleObject_EnumVerbs ( IOleObject *  iface, IEnumOLEVERB **  ppEnumOleVerb  )

static

Definition at line 414 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_EnumVerbs");
    return E_NOTIMPL;
}

OleObject_GetClientSite()

static HRESULT WINAPI OleObject_GetClientSite ( IOleObject *  iface, IOleClientSite **  ppClientSite  )

static

Definition at line 322 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetClientSite");
    return E_NOTIMPL;
}

OleObject_GetClipboardData()

static HRESULT WINAPI OleObject_GetClipboardData ( IOleObject *  iface, DWORD  dwReserved, IDataObject **  ppDataObject  )

static

Definition at line 388 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetClipboardData");
    return E_NOTIMPL;
}

OleObject_GetExtent()

static HRESULT WINAPI OleObject_GetExtent ( IOleObject *  iface, DWORD  dwDrawAspect, SIZEL *  psizel  )

static

Definition at line 474 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetExtent");
    return E_NOTIMPL;
}

OleObject_GetMiscStatus()

static HRESULT WINAPI OleObject_GetMiscStatus ( IOleObject *  iface, DWORD  aspect, DWORD *  pdwStatus  )

static

Definition at line 516 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetMiscStatus");

    ok(aspect == DVASPECT_CONTENT, "got aspect %d\n", aspect);

    if (g_GetMiscStatusFailsWith == S_OK)
    {
        *pdwStatus = OLEMISC_RECOMPOSEONRESIZE;
        return S_OK;
    }
    else
    {
        *pdwStatus = 0x1234;
        return g_GetMiscStatusFailsWith;
    }
}

OleObject_GetMoniker()

static HRESULT WINAPI OleObject_GetMoniker ( IOleObject *  iface, DWORD  dwAssign, DWORD  dwWhichMoniker, IMoniker **  ppmk  )

static

Definition at line 364 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetMoniker");
    return S_OK;
}

OleObject_GetUserClassID()

static HRESULT WINAPI OleObject_GetUserClassID ( IOleObject *  iface, CLSID *  pClsid  )

static

Definition at line 442 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetUserClassID");
    return E_NOTIMPL;
}

OleObject_GetUserType()

static HRESULT WINAPI OleObject_GetUserType ( IOleObject *  iface, DWORD  dwFormOfType, LPOLESTR *  pszUserType  )

static

Definition at line 452 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_GetUserType");
    return E_NOTIMPL;
}

OleObject_InitFromData()

static HRESULT WINAPI OleObject_InitFromData ( IOleObject *  iface, IDataObject *  pDataObject, BOOL  fCreation, DWORD  dwReserved  )

static

Definition at line 376 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_InitFromData");
    return S_OK;
}

OleObject_IsUpToDate()

static HRESULT WINAPI OleObject_IsUpToDate ( IOleObject *  iface )

static

Definition at line 433 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_IsUpToDate");
    return S_OK;
}

OleObject_QueryInterface()

static HRESULT WINAPI OleObject_QueryInterface ( IOleObject *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 273 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_QueryInterface");

    *ppv = NULL;

    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IOleObject))
        *ppv = iface;
    else if (IsEqualIID(riid, &IID_IPersistStorage))
        *ppv = &OleObjectPersistStg;
    else if (IsEqualIID(riid, &IID_IOleCache))
        *ppv = cache;
    else if (IsEqualIID(riid, &IID_IRunnableObject) && g_showRunnable)
        *ppv = runnable;
    else if (IsEqualIID(riid, &IID_WineTest))
        return g_QIFailsWith;

    if(*ppv) {
        IUnknown_AddRef((IUnknown*)*ppv);
        return S_OK;
    }

    trace("OleObject_QueryInterface: returning E_NOINTERFACE\n");
    return E_NOINTERFACE;
}

OleObject_Release()

static ULONG WINAPI OleObject_Release ( IOleObject *  iface )

static

Definition at line 305 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_Release");
    return 1;
}

OleObject_SetClientSite()

static HRESULT WINAPI OleObject_SetClientSite ( IOleObject *  iface, IOleClientSite *  pClientSite  )

static

Definition at line 312 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_SetClientSite");
    return S_OK;
}

OleObject_SetColorScheme()

static HRESULT WINAPI OleObject_SetColorScheme ( IOleObject *  iface, LOGPALETTE *  pLogpal  )

static

Definition at line 539 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_SetColorScheme");
    return E_NOTIMPL;
}

OleObject_SetExtent()

static HRESULT WINAPI OleObject_SetExtent ( IOleObject *  iface, DWORD  dwDrawAspect, SIZEL *  psizel  )

static

Definition at line 463 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_SetExtent");
    return S_OK;
}

OleObject_SetHostNames()

static HRESULT WINAPI OleObject_SetHostNames ( IOleObject *  iface, LPCOLESTR  szContainerApp, LPCOLESTR  szContainerObj  )

static

Definition at line 332 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_SetHostNames");
    return S_OK;
}

OleObject_SetMoniker()

static HRESULT WINAPI OleObject_SetMoniker ( IOleObject *  iface, DWORD  dwWhichMoniker, IMoniker *  pmk  )

static

Definition at line 353 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_SetMoniker");
    return S_OK;
}

OleObject_Unadvise()

static HRESULT WINAPI OleObject_Unadvise ( IOleObject *  iface, DWORD  dwConnection  )

static

Definition at line 496 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_Unadvise");
    return S_OK;
}

OleObject_Update()

static HRESULT WINAPI OleObject_Update ( IOleObject *  iface )

static

Definition at line 424 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObject_Update");
    return S_OK;
}

OleObjectCache_AddRef()

static ULONG WINAPI OleObjectCache_AddRef ( IOleCache *  iface )

static

Definition at line 682 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_AddRef");
    return 2;
}

OleObjectCache_Cache()

static HRESULT WINAPI OleObjectCache_Cache ( IOleCache *  iface, FORMATETC *  pformatetc, DWORD  advf, DWORD *  pdwConnection  )

static

Definition at line 695 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_Cache");
    if (g_expected_fetc) {
        ok(pformatetc != NULL, "pformatetc should not be NULL\n");
        if (pformatetc) {
            ok(pformatetc->cfFormat == g_expected_fetc->cfFormat,
                    "cfFormat: %x\n", pformatetc->cfFormat);
            ok((pformatetc->ptd != NULL) == (g_expected_fetc->ptd != NULL),
                    "ptd: %p\n", pformatetc->ptd);
            ok(pformatetc->dwAspect == g_expected_fetc->dwAspect,
                    "dwAspect: %x\n", pformatetc->dwAspect);
            ok(pformatetc->lindex == g_expected_fetc->lindex,
                    "lindex: %x\n", pformatetc->lindex);
            ok(pformatetc->tymed == g_expected_fetc->tymed,
                    "tymed: %x\n", pformatetc->tymed);
        }
    } else
        ok(pformatetc == NULL, "pformatetc should be NULL\n");
    return S_OK;
}

OleObjectCache_EnumCache()

static HRESULT WINAPI OleObjectCache_EnumCache ( IOleCache *  iface, IEnumSTATDATA **  ppenumSTATDATA  )

static

Definition at line 733 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_EnumCache");
    return S_OK;
}

OleObjectCache_InitCache()

static HRESULT WINAPI OleObjectCache_InitCache ( IOleCache *  iface, IDataObject *  pDataObject  )

static

Definition at line 744 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_InitCache");
    return S_OK;
}

OleObjectCache_QueryInterface()

static HRESULT WINAPI OleObjectCache_QueryInterface ( IOleCache *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 677 of file ole2.c.

{
    return IOleObject_QueryInterface(&OleObject, riid, ppv);
}

OleObjectCache_Release()

static ULONG WINAPI OleObjectCache_Release ( IOleCache *  iface )

static

Definition at line 688 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_Release");
    return 1;
}

OleObjectCache_SetData()

static HRESULT WINAPI OleObjectCache_SetData ( IOleCache *  iface, FORMATETC *  pformatetc, STGMEDIUM *  pmedium, BOOL  fRelease  )

static

Definition at line 755 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_SetData");
    return S_OK;
}

OleObjectCache_Uncache()

static HRESULT WINAPI OleObjectCache_Uncache ( IOleCache *  iface, DWORD  dwConnection  )

static

Definition at line 723 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectCache_Uncache");
    return S_OK;
}

OleObjectCF_AddRef()

static ULONG WINAPI OleObjectCF_AddRef ( IClassFactory *  iface )

static

Definition at line 793 of file ole2.c.

{
    return 2;
}

OleObjectCF_CreateInstance()

static HRESULT WINAPI OleObjectCF_CreateInstance ( IClassFactory *  iface, IUnknown *  punkOuter, REFIID  riid, void **  ppv  )

static

Definition at line 803 of file ole2.c.

{
    return IOleObject_QueryInterface(&OleObject, riid, ppv);
}

OleObjectCF_LockServer()

static HRESULT WINAPI OleObjectCF_LockServer ( IClassFactory *  iface, BOOL  lock  )

static

Definition at line 808 of file ole2.c.

{
    return S_OK;
}

OleObjectCF_QueryInterface()

static HRESULT WINAPI OleObjectCF_QueryInterface ( IClassFactory *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 781 of file ole2.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
    {
        *ppv = iface;
        IClassFactory_AddRef(iface);
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

OleObjectCF_Release()

static ULONG WINAPI OleObjectCF_Release ( IClassFactory *  iface )

static

Definition at line 798 of file ole2.c.

{
    return 1;
}

OleObjectPersistStg_AddRef()

static ULONG WINAPI OleObjectPersistStg_AddRef ( IPersistStorage *  iface )

static

Definition at line 584 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_AddRef");
    return 2;
}

OleObjectPersistStg_GetClassId()

static HRESULT WINAPI OleObjectPersistStg_GetClassId ( IPersistStorage *  iface, CLSID *  clsid  )

static

Definition at line 596 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_GetClassId");
    return E_NOTIMPL;
}

OleObjectPersistStg_HandsOffStorage()

static HRESULT WINAPI OleObjectPersistStg_HandsOffStorage ( IPersistStorage *  iface )

static

Definition at line 653 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_HandsOffStorage");
    return S_OK;
}

OleObjectPersistStg_InitNew()

static HRESULT WINAPI OleObjectPersistStg_InitNew ( IPersistStorage *  iface, IStorage *  pStg  )

static

Definition at line 612 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_InitNew");
    return S_OK;
}

OleObjectPersistStg_IsDirty()

static HRESULT WINAPI OleObjectPersistStg_IsDirty ( IPersistStorage *  iface )

static

Definition at line 603 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_IsDirty");
    return S_OK;
}

OleObjectPersistStg_Load()

static HRESULT WINAPI OleObjectPersistStg_Load ( IPersistStorage *  iface, IStorage *  pStg  )

static

Definition at line 622 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_Load");
    return S_OK;
}

OleObjectPersistStg_QueryInterface()

static HRESULT WINAPI OleObjectPersistStg_QueryInterface ( IPersistStorage *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 578 of file ole2.c.

{
    trace("OleObjectPersistStg_QueryInterface\n");
    return IOleObject_QueryInterface(&OleObject, riid, ppv);
}

OleObjectPersistStg_Release()

static ULONG WINAPI OleObjectPersistStg_Release ( IPersistStorage *  iface )

static

Definition at line 590 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_Release");
    return 1;
}

OleObjectPersistStg_Save()

static HRESULT WINAPI OleObjectPersistStg_Save ( IPersistStorage *  iface, IStorage *  pStgSave, BOOL  fSameAsLoad  )

static

Definition at line 632 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_Save");
    return S_OK;
}

OleObjectPersistStg_SaveCompleted()

static HRESULT WINAPI OleObjectPersistStg_SaveCompleted ( IPersistStorage *  iface, IStorage *  pStgNew  )

static

Definition at line 643 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectPersistStg_SaveCompleted");
    return S_OK;
}

OleObjectRunnable_AddRef()

static ULONG WINAPI OleObjectRunnable_AddRef ( IRunnableObject *  iface )

static

Definition at line 829 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_AddRef");
    return 2;
}

OleObjectRunnable_GetRunningClass()

static HRESULT WINAPI OleObjectRunnable_GetRunningClass ( IRunnableObject *  iface, LPCLSID  lpClsid  )

static

Definition at line 841 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_GetRunningClass");
    return E_NOTIMPL;
}

OleObjectRunnable_IsRunning()

static BOOL WINAPI OleObjectRunnable_IsRunning ( IRunnableObject *  iface )

static

Definition at line 857 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_IsRunning");
    return g_isRunning;
}

OleObjectRunnable_LockRunning()

static HRESULT WINAPI OleObjectRunnable_LockRunning ( IRunnableObject *  iface, BOOL  fLock, BOOL  fLastUnlockCloses  )

static

Definition at line 863 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_LockRunning");
    return S_OK;
}

OleObjectRunnable_QueryInterface()

static HRESULT WINAPI OleObjectRunnable_QueryInterface ( IRunnableObject *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 824 of file ole2.c.

{
    return IOleObject_QueryInterface(&OleObject, riid, ppv);
}

OleObjectRunnable_Release()

static ULONG WINAPI OleObjectRunnable_Release ( IRunnableObject *  iface )

static

Definition at line 835 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_Release");
    return 1;
}

OleObjectRunnable_Run()

static HRESULT WINAPI OleObjectRunnable_Run ( IRunnableObject *  iface, LPBINDCTX  pbc  )

static

Definition at line 849 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_Run");
    return S_OK;
}

OleObjectRunnable_SetContainedObject()

static HRESULT WINAPI OleObjectRunnable_SetContainedObject ( IRunnableObject *  iface, BOOL  fContained  )

static

Definition at line 872 of file ole2.c.

{
    CHECK_EXPECTED_METHOD("OleObjectRunnable_SetContainedObject");
    return S_OK;
}

OleRun_AddRef()

static ULONG WINAPI OleRun_AddRef ( IRunnableObject *  iface )

static

Definition at line 3215 of file ole2.c.

{
    return 2;
}

OleRun_GetRunningClass()

static HRESULT WINAPI OleRun_GetRunningClass ( IRunnableObject *  iface, CLSID *  clsid  )

static

Definition at line 3225 of file ole2.c.

{
    ok(0, "unexpected\n");
    return E_NOTIMPL;
}

OleRun_IsRunning()

static BOOL WINAPI OleRun_IsRunning ( IRunnableObject *  iface )

static

Definition at line 3237 of file ole2.c.

{
    ok(0, "unexpected\n");
    return FALSE;
}

OleRun_LockRunning()

static HRESULT WINAPI OleRun_LockRunning ( IRunnableObject *  iface, BOOL  lock, BOOL  last_unlock_closes  )

static

Definition at line 3243 of file ole2.c.

{
    ok(0, "unexpected\n");
    return E_NOTIMPL;
}

OleRun_QueryInterface()

static HRESULT WINAPI OleRun_QueryInterface ( IRunnableObject *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 3197 of file ole2.c.

{
    *ppv = NULL;

    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IRunnableObject)) {
        *ppv = iface;
    }

    if (*ppv)
    {
        IUnknown_AddRef((IUnknown *)*ppv);
        return S_OK;
    }

    return E_NOINTERFACE;
}

OleRun_Release()

static ULONG WINAPI OleRun_Release ( IRunnableObject *  iface )

static

Definition at line 3220 of file ole2.c.

{
    return 1;
}

OleRun_Run()

static HRESULT WINAPI OleRun_Run ( IRunnableObject *  iface, LPBINDCTX  ctx  )

static

Definition at line 3231 of file ole2.c.

{
    ok(ctx == NULL, "got %p\n", ctx);
    return 0xdeadc0de;
}

OleRun_SetContainedObject()

static HRESULT WINAPI OleRun_SetContainedObject ( IRunnableObject *  iface, BOOL  contained  )

static

Definition at line 3250 of file ole2.c.

{
    ok(0, "unexpected\n");
    return E_NOTIMPL;
}

read_clipformat()

static int read_clipformat ( IStream *  stream )

static

Definition at line 3971 of file ole2.c.

{
    HRESULT hr;
    ULONG bytes;
    int length, clipformat = -2;

    hr = IStream_Read(stream, &length, sizeof(length), &bytes);
    if (hr != S_OK || bytes != sizeof(length))
        return -2;
    if (length == 0)
        return 0;
    if (length == -1)
    {
        hr = IStream_Read(stream, &clipformat, sizeof(clipformat), &bytes);
        if (hr != S_OK || bytes != sizeof(clipformat))
            return -2;
    }
    else
        ok(0, "unhandled clipformat length %d\n", length);

    return clipformat;
}

Referenced by check_storage_contents().

START_TEST()

START_TEST

(

ole2

)

Definition at line 4786 of file ole2.c.

{
    DWORD dwRegister;
    IStorage *pStorage;
    STATSTG statstg;
    HRESULT hr;

    cf_test_1 = RegisterClipboardFormatA("cf_winetest_1");
    cf_test_2 = RegisterClipboardFormatA("cf_winetest_2");
    cf_test_3 = RegisterClipboardFormatA("cf_winetest_3");

    CoInitialize(NULL);

    hr = CoRegisterClassObject(&CLSID_Equation3, (IUnknown *)&OleObjectCF, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
    ok_ole_success(hr, "CoRegisterClassObject");

    hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
    ok_ole_success(hr, "StgCreateDocfile");

    test_OleCreate(pStorage);

    hr = IStorage_Stat(pStorage, &statstg, STATFLAG_NONAME);
    ok_ole_success(hr, "IStorage_Stat");
    ok(IsEqualCLSID(&CLSID_Equation3, &statstg.clsid), "Wrong CLSID in storage\n");

    test_OleLoad(pStorage);

    IStorage_Release(pStorage);

    hr = CoRevokeClassObject(dwRegister);
    ok_ole_success(hr, "CoRevokeClassObject");

    Storage_SetClass_CLSID = &CLSID_WineTest;

    test_data_cache();
    test_data_cache_dib_contents_stream( 0 );
    test_data_cache_dib_contents_stream( 1 );
    test_data_cache_cache();
    test_data_cache_init();
    test_data_cache_initnew();
    test_data_cache_updatecache();
    test_default_handler();
    test_runnable();
    test_OleRun();
    test_OleLockRunning();
    test_OleDraw();
    test_OleDoAutoConvert();
    test_data_cache_save();
    test_data_cache_save_data();
    test_data_cache_contents();
    test_OleCreateStaticFromData();

    CoUninitialize();
}

stgmedium_cmp()

static HRESULT stgmedium_cmp ( const STGMEDIUM *  med1, STGMEDIUM *  med2  )

static

Definition at line 4102 of file ole2.c.

{
    BYTE *data1, *data2;
    ULONG datasize1, datasize2;

    if (med1->tymed != med2->tymed)
        return E_FAIL;

    if (med1->tymed == TYMED_MFPICT)
    {
        METAFILEPICT *mfpict1 = GlobalLock(U(med1)->hMetaFilePict);
        METAFILEPICT *mfpict2 = GlobalLock(U(med2)->hMetaFilePict);

        datasize1 = GetMetaFileBitsEx(mfpict1->hMF, 0, NULL);
        datasize2 = GetMetaFileBitsEx(mfpict2->hMF, 0, NULL);
        if (datasize1 == datasize2)
        {
            data1 = HeapAlloc(GetProcessHeap(), 0, datasize1);
            data2 = HeapAlloc(GetProcessHeap(), 0, datasize2);
            GetMetaFileBitsEx(mfpict1->hMF, datasize1, data1);
            GetMetaFileBitsEx(mfpict2->hMF, datasize2, data2);
        }
        else return E_FAIL;
    }
    else if (med1->tymed == TYMED_ENHMF)
    {
        datasize1 = GetEnhMetaFileBits(med1->hEnhMetaFile, 0, NULL);
        datasize2 = GetEnhMetaFileBits(med2->hEnhMetaFile, 0, NULL);
        if (datasize1 == datasize2)
        {
            data1 = HeapAlloc(GetProcessHeap(), 0, datasize1);
            data2 = HeapAlloc(GetProcessHeap(), 0, datasize2);
            GetEnhMetaFileBits(med1->hEnhMetaFile, datasize1, data1);
            GetEnhMetaFileBits(med2->hEnhMetaFile, datasize2, data2);
        }
        else return E_FAIL;
    }
    else if (med1->tymed == TYMED_HGLOBAL)
    {
        datasize1 = GlobalSize(med1->hGlobal);
        datasize2 = GlobalSize(med2->hGlobal);

        if (datasize1 == datasize2)
        {
            data1 = GlobalLock(med1->hGlobal);
            data2 = GlobalLock(med2->hGlobal);
        }
        else
            return E_FAIL;
    }
    else
        return E_NOTIMPL;

    if (memcmp(data1, data2, datasize1) != 0)
        return E_FAIL;

    if (med1->tymed == TYMED_HGLOBAL)
    {
        GlobalUnlock(U(med1)->hGlobal);
        GlobalUnlock(U(med2)->hGlobal);
    }
    else if (med1->tymed == TYMED_MFPICT)
    {
        HeapFree(GetProcessHeap(), 0, data1);
        HeapFree(GetProcessHeap(), 0, data2);
        GlobalUnlock(U(med1)->hMetaFilePict);
        GlobalUnlock(U(med2)->hMetaFilePict);
    }
    else
    {
        HeapFree(GetProcessHeap(), 0, data1);
        HeapFree(GetProcessHeap(), 0, data2);
    }

    return S_OK;
}

Referenced by test_data_cache_save_data().

Storage_AddRef()

static ULONG WINAPI Storage_AddRef ( IStorage *  iface )

static

Definition at line 3318 of file ole2.c.

{
    ok(0, "unexpected call to AddRef\n");
    return 2;
}

Storage_Commit()

static HRESULT WINAPI Storage_Commit ( IStorage *  iface, DWORD  grfCommitFlags  )

static

Definition at line 3452 of file ole2.c.

{
    ok(0, "unexpected call to Commit\n");
    return E_NOTIMPL;
}

Storage_CopyTo()

static HRESULT WINAPI Storage_CopyTo ( IStorage *  iface, DWORD  ciidExclude, const IID *  rgiidExclude, SNB  snbExclude, IStorage *  pstgDest  )

static

Definition at line 3440 of file ole2.c.

{
    ok(0, "unexpected call to CopyTo\n");
    return E_NOTIMPL;
}

Storage_CreateStorage()

static HRESULT WINAPI Storage_CreateStorage ( IStorage *  iface, LPCOLESTR  pwcsName, DWORD  grfMode, DWORD  dwStgFmt, DWORD  reserved2, IStorage **  ppstg  )

static

Definition at line 3428 of file ole2.c.

{
    ok(0, "unexpected call to CreateStorage\n");
    return E_NOTIMPL;
}

Storage_CreateStream()

static HRESULT WINAPI Storage_CreateStream ( IStorage *  iface, LPCOLESTR  pwcsName, DWORD  grfMode, DWORD  reserved1, DWORD  reserved2, IStream **  ppstm  )

static

Definition at line 3330 of file ole2.c.

{
    ULARGE_INTEGER size = {{0}};
    LARGE_INTEGER pos = {{0}};
    HRESULT hr;

    if (!lstrcmpW(pwcsName, comp_objW))
    {
        CHECK_EXPECT(Storage_CreateStream_CompObj);
        *ppstm = comp_obj_stream;

        todo_wine ok(grfMode == (STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);
    }
    else if (!lstrcmpW(pwcsName, olepres0W))
    {
        CHECK_EXPECT(Storage_CreateStream_OlePres);
        *ppstm = olepres_stream;

        todo_wine ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);
    }
    else
    {
todo_wine
        ok(0, "unexpected stream name %s\n", wine_dbgstr_w(pwcsName));
#if 0   /* FIXME: return NULL once Wine is fixed */
        *ppstm = NULL;
        return E_NOTIMPL;
#else
        *ppstm = contents_stream;
#endif
    }

    ok(!reserved1, "reserved1 = %x\n", reserved1);
    ok(!reserved2, "reserved2 = %x\n", reserved2);
    ok(!!ppstm, "ppstm = NULL\n");

    IStream_AddRef(*ppstm);
    hr = IStream_Seek(*ppstm, pos, STREAM_SEEK_SET, NULL);
    ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
    hr = IStream_SetSize(*ppstm, size);
    ok(hr == S_OK, "IStream_SetSize returned %x\n", hr);
    return S_OK;
}

Storage_DestroyElement()

static HRESULT WINAPI Storage_DestroyElement ( IStorage *  iface, LPCOLESTR  pwcsName  )

static

Definition at line 3470 of file ole2.c.

{
    char name[32];
    int stream_n, cmp;

    CHECK_EXPECT2(Storage_DestroyElement);
    cmp = CompareStringW(LOCALE_NEUTRAL, 0, pwcsName, 8, olepres0W, 8);
    ok(cmp == CSTR_EQUAL,
       "unexpected call to DestroyElement(%s)\n", wine_dbgstr_w(pwcsName));

    WideCharToMultiByte(CP_ACP, 0, pwcsName, -1, name, sizeof(name), NULL, NULL);
    stream_n = atol(name + 8);
    if (stream_n <= Storage_DestroyElement_limit)
        return S_OK;

    return STG_E_FILENOTFOUND;
}

Referenced by test_data_cache_save().

Storage_EnumElements()

static HRESULT WINAPI Storage_EnumElements ( IStorage *  iface, DWORD  reserved1, void *  reserved2, DWORD  reserved3, IEnumSTATSTG **  ppenum  )

static

Definition at line 3464 of file ole2.c.

{
    ok(0, "unexpected call to EnumElements\n");
    return E_NOTIMPL;
}

Storage_MoveElementTo()

static HRESULT WINAPI Storage_MoveElementTo ( IStorage *  iface, LPCOLESTR  pwcsName, IStorage *  pstgDest, LPCOLESTR  pwcsNewName, DWORD  grfFlags  )

static

Definition at line 3446 of file ole2.c.

{
    ok(0, "unexpected call to MoveElementTo\n");
    return E_NOTIMPL;
}

Storage_OpenStorage()

static HRESULT WINAPI Storage_OpenStorage ( IStorage *  iface, LPCOLESTR  pwcsName, IStorage *  pstgPriority, DWORD  grfMode, SNB  snbExclude, DWORD  reserved, IStorage **  ppstg  )

static

Definition at line 3434 of file ole2.c.

{
    ok(0, "unexpected call to OpenStorage\n");
    return E_NOTIMPL;
}

Storage_OpenStream()

static HRESULT WINAPI Storage_OpenStream ( IStorage *  iface, LPCOLESTR  pwcsName, void *  reserved1, DWORD  grfMode, DWORD  reserved2, IStream **  ppstm  )

static

Definition at line 3374 of file ole2.c.

{
    static  const WCHAR ole1W[] = {1,'O','l','e',0};

    LARGE_INTEGER pos = {{0}};
    HRESULT hr;

    ok(!reserved1, "reserved1 = %p\n", reserved1);
    ok(!reserved2, "reserved2 = %x\n", reserved2);
    ok(!!ppstm, "ppstm = NULL\n");

    if(!lstrcmpW(pwcsName, comp_objW)) {
        CHECK_EXPECT2(Storage_OpenStream_CompObj);
        ok(grfMode == STGM_SHARE_EXCLUSIVE, "grfMode = %x\n", grfMode);

        *ppstm = comp_obj_stream;
        IStream_AddRef(comp_obj_stream);
        hr = IStream_Seek(comp_obj_stream, pos, STREAM_SEEK_SET, NULL);
        ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
        return S_OK;
    }else if(!lstrcmpW(pwcsName, ole1W)) {
        CHECK_EXPECT(Storage_OpenStream_Ole);

        if (!ole_stream)
        {
            ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READ), "grfMode = %x\n", grfMode);

            *ppstm = NULL;
            return STG_E_FILENOTFOUND;
        }

        ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);

        *ppstm = ole_stream;
        IStream_AddRef(ole_stream);
        hr = IStream_Seek(ole_stream, pos, STREAM_SEEK_SET, NULL);
        ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
        return S_OK;

    }else if(!lstrcmpW(pwcsName, olepres0W)) {
        CHECK_EXPECT(Storage_OpenStream_OlePres);
        ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);

        *ppstm = olepres_stream;
        IStream_AddRef(olepres_stream);
        hr = IStream_Seek(olepres_stream, pos, STREAM_SEEK_SET, NULL);
        ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
        return S_OK;
    }

    ok(0, "unexpected call to OpenStream: %s\n", wine_dbgstr_w(pwcsName));
    return E_NOTIMPL;
}

Storage_QueryInterface()

static HRESULT WINAPI Storage_QueryInterface ( IStorage *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 3312 of file ole2.c.

{
    ok(0, "unexpected call to QueryInterface\n");
    return E_NOTIMPL;
}

Storage_Release()

static ULONG WINAPI Storage_Release ( IStorage *  iface )

static

Definition at line 3324 of file ole2.c.

{
    ok(0, "unexpected call to Release\n");
    return 1;
}

Storage_RenameElement()

static HRESULT WINAPI Storage_RenameElement ( IStorage *  iface, LPCOLESTR  pwcsOldName, LPCOLESTR  pwcsNewName  )

static

Definition at line 3488 of file ole2.c.

{
    ok(0, "unexpected call to RenameElement\n");
    return E_NOTIMPL;
}

Storage_Revert()

static HRESULT WINAPI Storage_Revert ( IStorage *  iface )

static

Definition at line 3458 of file ole2.c.

{
    ok(0, "unexpected call to Revert\n");
    return E_NOTIMPL;
}

Storage_SetClass()

static HRESULT WINAPI Storage_SetClass ( IStorage *  iface, REFCLSID  clsid  )

static

Definition at line 3500 of file ole2.c.

{
    CHECK_EXPECT(Storage_SetClass);
    ok(IsEqualIID(clsid, Storage_SetClass_CLSID), "expected %s, got %s\n",
       wine_dbgstr_guid(Storage_SetClass_CLSID), wine_dbgstr_guid(clsid));
    return S_OK;
}

Referenced by test_OleDoAutoConvert().

Storage_SetElementTimes()

static HRESULT WINAPI Storage_SetElementTimes ( IStorage *  iface, LPCOLESTR  pwcsName, const FILETIME *  pctime, const FILETIME *  patime, const FILETIME *  pmtime  )

static

Definition at line 3494 of file ole2.c.

{
    ok(0, "unexpected call to SetElementTimes\n");
    return E_NOTIMPL;
}

Storage_SetStateBits()

static HRESULT WINAPI Storage_SetStateBits ( IStorage *  iface, DWORD  grfStateBits, DWORD  grfMask  )

static

Definition at line 3508 of file ole2.c.

{
    ok(0, "unexpected call to SetStateBits\n");
    return E_NOTIMPL;
}

Storage_Stat()

static HRESULT WINAPI Storage_Stat ( IStorage *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 3514 of file ole2.c.

{
    CHECK_EXPECT2(Storage_Stat);
    ok(pstatstg != NULL, "pstatstg = NULL\n");
    ok(grfStatFlag == STATFLAG_NONAME, "grfStatFlag = %x\n", grfStatFlag);

    memset(pstatstg, 0, sizeof(STATSTG));
    pstatstg->type = STGTY_STORAGE;
    pstatstg->clsid = CLSID_WineTestOld;
    return S_OK;
}

Referenced by test_OleDoAutoConvert().

test_data_cache()

static void test_data_cache ( void  )

static

Definition at line 1692 of file ole2.c.

{
    HRESULT hr;
    IOleCache2 *pOleCache;
    IOleCache *olecache;
    IStorage *pStorage;
    IUnknown *unk, *unk2;
    IPersistStorage *pPS;
    IViewObject *pViewObject;
    IOleCacheControl *pOleCacheControl;
    IDataObject *pCacheDataObject;
    FORMATETC fmtetc;
    STGMEDIUM stgmedium;
    DWORD dwConnection;
    DWORD dwFreeze;
    RECTL rcBounds;
    HDC hdcMem;
    CLSID clsid;
    char szSystemDir[MAX_PATH];
    WCHAR wszPath[MAX_PATH];
    static const WCHAR wszShell32[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0};

    static const struct expected_method methods_cacheinitnew[] =
    {
        { "AdviseSink_OnViewChange", 0 },
        { "AdviseSink_OnViewChange", 0 },
        { "draw_continue", 1 },
        { "draw_continue_false", 1 },
        { "DataObject_DAdvise", 0 },
        { "DataObject_DAdvise", 0 },
        { "DataObject_DUnadvise", 0 },
        { "DataObject_DUnadvise", 0 },
        { NULL, 0 }
    };
    static const struct expected_method methods_cacheload[] =
    {
        { "AdviseSink_OnViewChange", 0 },
        { "draw_continue", 1 },
        { "draw_continue", 1 },
        { "draw_continue", 1 },
        { "DataObject_GetData", 0, { CF_DIB,          NULL, DVASPECT_THUMBNAIL, -1, TYMED_HGLOBAL} },
        { "DataObject_GetData", 0, { CF_BITMAP,       NULL, DVASPECT_THUMBNAIL, -1, TYMED_GDI} },
        { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_ICON,      -1, TYMED_MFPICT} },
        { NULL, 0 }
    };
    static const struct expected_method methods_cachethenrun[] =
    {
        { "DataObject_DAdvise", 0 },
        { "DataObject_DAdvise", 0 },
        { "DataObject_DAdvise", 0 },
        { "DataObject_DAdvise", 0 },
        { "DataObject_DUnadvise", 0 },
        { "DataObject_DUnadvise", 0 },
        { "DataObject_DUnadvise", 0 },
        { "DataObject_DUnadvise", 0 },
        { NULL, 0 }
    };

    GetSystemDirectoryA(szSystemDir, ARRAY_SIZE(szSystemDir));

    expected_method_list = methods_cacheinitnew;

    fmtetc.cfFormat = CF_METAFILEPICT;
    fmtetc.dwAspect = DVASPECT_ICON;
    fmtetc.lindex = -1;
    fmtetc.ptd = NULL;
    fmtetc.tymed = TYMED_MFPICT;

    hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
    ok_ole_success(hr, "StgCreateDocfile");

    /* aggregation */

    /* requested is not IUnknown */
    hr = CreateDataCache(&unknown, &CLSID_NULL, &IID_IOleCache2, (void**)&pOleCache);
    ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);

    hr = CreateDataCache(&unknown, &CLSID_NULL, &IID_IUnknown, (void**)&unk);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = IUnknown_QueryInterface(unk, &IID_IOleCache, (void**)&olecache);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    hr = IUnknown_QueryInterface(unk, &IID_IOleCache2, (void**)&pOleCache);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(unk != (IUnknown*)olecache, "got %p, expected %p\n", olecache, unk);
    ok(unk != (IUnknown*)pOleCache, "got %p, expected %p\n", pOleCache, unk);
    IOleCache2_Release(pOleCache);
    IOleCache_Release(olecache);
    IUnknown_Release(unk);

    hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IUnknown, (void**)&unk);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    hr = IUnknown_QueryInterface(unk, &IID_IOleCache, (void**)&olecache);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    hr = IUnknown_QueryInterface(unk, &IID_IOleCache2, (void**)&pOleCache);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    hr = IUnknown_QueryInterface(unk, &IID_IUnknown, (void**)&unk2);
    ok(hr == S_OK, "got 0x%08x\n", hr);
    ok(unk == (IUnknown*)olecache, "got %p, expected %p\n", olecache, unk);
    ok(unk == (IUnknown*)pOleCache, "got %p, expected %p\n", pOleCache, unk);
    ok(unk == unk2, "got %p, expected %p\n", unk2, unk);
    IUnknown_Release(unk2);
    IOleCache2_Release(pOleCache);
    IOleCache_Release(olecache);
    IUnknown_Release(unk);

    /* Test with new data */

    hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
    ok_ole_success(hr, "CreateDataCache");

    hr = IOleCache2_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
    hr = IOleCache2_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
    hr = IOleCache2_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");

    hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
    ok_ole_success(hr, "IViewObject_SetAdvise");

    hr = IPersistStorage_InitNew(pPS, pStorage);
    ok_ole_success(hr, "IPersistStorage_InitNew");

    hr = IPersistStorage_IsDirty(pPS);
    ok_ole_success(hr, "IPersistStorage_IsDirty");

    hr = IPersistStorage_GetClassID(pPS, &clsid);
    ok_ole_success(hr, "IPersistStorage_GetClassID");
    ok(IsEqualCLSID(&clsid, &IID_NULL), "clsid should be blank\n");

    hr = IOleCache2_Uncache(pOleCache, 0xdeadbeef);
    ok(hr == OLE_E_NOCONNECTION, "IOleCache_Uncache with invalid value should return OLE_E_NOCONNECTION instead of 0x%x\n", hr);

    /* Both tests crash on NT4 and below. StgCreatePropSetStg is only available on w2k and above. */
    if (GetProcAddress(GetModuleHandleA("ole32.dll"), "StgCreatePropSetStg"))
    {
        hr = IOleCache2_Cache(pOleCache, NULL, 0, &dwConnection);
        ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL fmtetc should have returned E_INVALIDARG instead of 0x%08x\n", hr);

        hr = IOleCache2_Cache(pOleCache, NULL, 0, NULL);
        ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL pdwConnection should have returned E_INVALIDARG instead of 0x%08x\n", hr);
    }
    else
    {
        skip("tests with NULL parameters will crash on NT4 and below\n");
    }

    for (fmtetc.cfFormat = CF_TEXT; fmtetc.cfFormat < CF_MAX; fmtetc.cfFormat++)
    {
        int i;
        fmtetc.dwAspect = DVASPECT_THUMBNAIL;
        for (i = 0; i < 7; i++)
        {
            fmtetc.tymed = 1 << i;
            hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
            if ((fmtetc.cfFormat == CF_METAFILEPICT && fmtetc.tymed == TYMED_MFPICT) ||
                (fmtetc.cfFormat == CF_BITMAP && fmtetc.tymed == TYMED_GDI) ||
                (fmtetc.cfFormat == CF_DIB && fmtetc.tymed == TYMED_HGLOBAL) ||
                (fmtetc.cfFormat == CF_ENHMETAFILE && fmtetc.tymed == TYMED_ENHMF))
                ok(hr == S_OK, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned S_OK instead of 0x%08x\n",
                    fmtetc.cfFormat, fmtetc.tymed, hr);
            else if (fmtetc.tymed == TYMED_HGLOBAL)
                ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED ||
                   broken(hr == S_OK && fmtetc.cfFormat == CF_BITMAP) /* Win9x & NT4 */,
                    "IOleCache_Cache cfFormat = %d, tymed = %d should have returned CACHE_S_FORMATETC_NOTSUPPORTED instead of 0x%08x\n",
                    fmtetc.cfFormat, fmtetc.tymed, hr);
            else
                ok(hr == DV_E_TYMED, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned DV_E_TYMED instead of 0x%08x\n",
                    fmtetc.cfFormat, fmtetc.tymed, hr);
            if (SUCCEEDED(hr))
            {
                hr = IOleCache2_Uncache(pOleCache, dwConnection);
                ok_ole_success(hr, "IOleCache_Uncache");
            }
        }
    }

    fmtetc.cfFormat = CF_BITMAP;
    fmtetc.dwAspect = DVASPECT_THUMBNAIL;
    fmtetc.tymed = TYMED_GDI;
    hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
    ok_ole_success(hr, "IOleCache_Cache");

    fmtetc.cfFormat = 0;
    fmtetc.dwAspect = DVASPECT_ICON;
    fmtetc.tymed = TYMED_MFPICT;
    hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
    ok_ole_success(hr, "IOleCache_Cache");

    MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszPath, ARRAY_SIZE(wszPath));
    memcpy(wszPath+lstrlenW(wszPath), wszShell32, sizeof(wszShell32));

    fmtetc.cfFormat = CF_METAFILEPICT;
    stgmedium.tymed = TYMED_MFPICT;
    U(stgmedium).hMetaFilePict = OleMetafilePictFromIconAndLabel(
        LoadIconA(NULL, (LPSTR)IDI_APPLICATION), wszPath, wszPath, 0);
    stgmedium.pUnkForRelease = NULL;

    fmtetc.dwAspect = DVASPECT_CONTENT;
    hr = IOleCache2_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
    ok(hr == OLE_E_BLANK, "IOleCache_SetData for aspect not in cache should have return OLE_E_BLANK instead of 0x%08x\n", hr);

    fmtetc.dwAspect = DVASPECT_ICON;
    hr = IOleCache2_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
    ok_ole_success(hr, "IOleCache_SetData");
    ReleaseStgMedium(&stgmedium);

    hr = IViewObject_Freeze(pViewObject, DVASPECT_ICON, -1, NULL, &dwFreeze);
    todo_wine {
    ok_ole_success(hr, "IViewObject_Freeze");
    hr = IViewObject_Freeze(pViewObject, DVASPECT_CONTENT, -1, NULL, &dwFreeze);
    ok(hr == OLE_E_BLANK, "IViewObject_Freeze with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
    }

    rcBounds.left = 0;
    rcBounds.top = 0;
    rcBounds.right = 100;
    rcBounds.bottom = 100;
    hdcMem = CreateCompatibleDC(NULL);

    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok_ole_success(hr, "IViewObject_Draw");

    hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);

    /* a NULL draw_continue fn ptr */
    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, NULL, 0xdeadbeef);
    ok_ole_success(hr, "IViewObject_Draw");

    /* draw_continue that returns FALSE to abort drawing */
    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue_false, 0xdeadbeef);
    ok(hr == E_ABORT ||
       broken(hr == S_OK), /* win9x may skip the callbacks */
       "IViewObject_Draw with draw_continue_false returns 0x%08x\n", hr);

    DeleteDC(hdcMem);

    hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
    ok_ole_success(hr, "IOleCacheControl_OnRun");

    hr = IPersistStorage_Save(pPS, pStorage, TRUE);
    ok_ole_success(hr, "IPersistStorage_Save");

    hr = IPersistStorage_SaveCompleted(pPS, NULL);
    ok_ole_success(hr, "IPersistStorage_SaveCompleted");

    hr = IPersistStorage_IsDirty(pPS);
    ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);

    IPersistStorage_Release(pPS);
    IViewObject_Release(pViewObject);
    IOleCache2_Release(pOleCache);
    IOleCacheControl_Release(pOleCacheControl);

    CHECK_NO_EXTRA_METHODS();

    /* Test with loaded data */
    trace("Testing loaded data with CreateDataCache:\n");
    expected_method_list = methods_cacheload;

    hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
    ok_ole_success(hr, "CreateDataCache");

    hr = IOleCache2_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
    hr = IOleCache2_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");

    hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
    ok_ole_success(hr, "IViewObject_SetAdvise");

    hr = IPersistStorage_Load(pPS, pStorage);
    ok_ole_success(hr, "IPersistStorage_Load");

    hr = IPersistStorage_IsDirty(pPS);
    ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);

    fmtetc.cfFormat = 0;
    fmtetc.dwAspect = DVASPECT_ICON;
    fmtetc.lindex = -1;
    fmtetc.ptd = NULL;
    fmtetc.tymed = TYMED_MFPICT;
    hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
    ok(hr == CACHE_S_SAMECACHE, "IOleCache_Cache with already loaded data format type should return CACHE_S_SAMECACHE instead of 0x%x\n", hr);

    rcBounds.left = 0;
    rcBounds.top = 0;
    rcBounds.right = 100;
    rcBounds.bottom = 100;
    hdcMem = CreateCompatibleDC(NULL);

    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok_ole_success(hr, "IViewObject_Draw");

    hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);

    /* unload the cached storage object, causing it to be reloaded */
    hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
    ok_ole_success(hr, "IOleCache2_DiscardCache");
    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok_ole_success(hr, "IViewObject_Draw");

    /* unload the cached storage object, but don't allow it to be reloaded */
    hr = IPersistStorage_HandsOffStorage(pPS);
    ok_ole_success(hr, "IPersistStorage_HandsOffStorage");
    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok_ole_success(hr, "IViewObject_Draw");
    hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
    ok_ole_success(hr, "IOleCache2_DiscardCache");
    hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
    ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);

    DeleteDC(hdcMem);

    hr = IOleCache2_InitCache(pOleCache, &DataObject);
    ok(hr == CACHE_E_NOCACHE_UPDATED, "IOleCache_InitCache should have returned CACHE_E_NOCACHE_UPDATED instead of 0x%08x\n", hr);

    IPersistStorage_Release(pPS);
    IViewObject_Release(pViewObject);
    IOleCache2_Release(pOleCache);

    CHECK_NO_EXTRA_METHODS();

    hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
    ok_ole_success(hr, "CreateDataCache");

    expected_method_list = methods_cachethenrun;

    hr = IOleCache2_QueryInterface(pOleCache, &IID_IDataObject, (LPVOID *)&pCacheDataObject);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IDataObject)");
    hr = IOleCache2_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
    ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");

    fmtetc.cfFormat = CF_METAFILEPICT;
    fmtetc.dwAspect = DVASPECT_CONTENT;
    fmtetc.tymed = TYMED_MFPICT;

    hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
    ok_ole_success(hr, "IOleCache_Cache");

    hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
    ok(hr == OLE_E_BLANK, "got %08x\n", hr);

    fmtetc.cfFormat = cf_test_1;
    fmtetc.dwAspect = DVASPECT_CONTENT;
    fmtetc.tymed = TYMED_HGLOBAL;

    hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
    ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);