tmarshal.c File Reference

#include <math.h>
#include <windows.h>
#include <ocidl.h>
#include <stdio.h>
#include "wine/test.h"
#include "tmarshal.h"

Include dependency graph for tmarshal.c:

Go to the source code of this file.

Classes
struct	host_object_data
struct	disp_obj
struct	coclass_obj
struct	Widget
struct	KindaEnum

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	ok_ole_success(hr, func)   ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
#define	release_iface(a)   release_iface_(__LINE__, a)
#define	ULL_CONST(dw1, dw2)   ((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)
#define	RELEASEMARSHALDATA   WM_USER

Typedefs
typedef struct Widget	Widget
typedef struct KindaEnum	KindaEnum

Functions
static	HRESULT (WINAPI *pVarAdd)(LPVARIANT
static void	release_iface_ (unsigned int line, void *iface)
static DWORD CALLBACK	host_object_proc (LPVOID p)
static DWORD	start_host_object2 (IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
static DWORD	start_host_object (IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
static void	end_host_object (DWORD tid, HANDLE thread)
static HRESULT WINAPI	ExternalConnection_QueryInterface (IExternalConnection *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ExternalConnection_AddRef (IExternalConnection *iface)
static ULONG WINAPI	ExternalConnection_Release (IExternalConnection *iface)
static DWORD WINAPI	ExternalConnection_AddConnection (IExternalConnection *iface, DWORD extconn, DWORD reserved)
static DWORD WINAPI	ExternalConnection_ReleaseConnection (IExternalConnection *iface, DWORD extconn, DWORD reserved, BOOL fLastReleaseCloses)
static HRESULT WINAPI	TestSecondIface_QueryInterface (ITestSecondIface *iface, REFIID riid, void **ppv)
static ULONG WINAPI	TestSecondIface_AddRef (ITestSecondIface *iface)
static ULONG WINAPI	TestSecondIface_Release (ITestSecondIface *iface)
static HRESULT WINAPI	TestSecondIface_test (ITestSecondIface *iface)
static HRESULT WINAPI	TestSecondDisp_QueryInterface (ITestSecondDisp *iface, REFIID riid, void **ppv)
static ULONG WINAPI	TestSecondDisp_AddRef (ITestSecondDisp *iface)
static ULONG WINAPI	TestSecondDisp_Release (ITestSecondDisp *iface)
static HRESULT WINAPI	TestSecondDisp_GetTypeInfoCount (ITestSecondDisp *iface, UINT *pctinfo)
static HRESULT WINAPI	TestSecondDisp_GetTypeInfo (ITestSecondDisp *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	TestSecondDisp_GetIDsOfNames (ITestSecondDisp *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	TestSecondDisp_Invoke (ITestSecondDisp *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	TestSecondDisp_test (ITestSecondDisp *iface)
static HRESULT WINAPI	TestDual_QueryInterface (ItestDual *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	TestDual_AddRef (ItestDual *iface)
static ULONG WINAPI	TestDual_Release (ItestDual *iface)
static HRESULT WINAPI	TestDual_GetTypeInfoCount (ItestDual *iface, UINT *pctinfo)
static HRESULT WINAPI	TestDual_GetTypeInfo (ItestDual *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	TestDual_GetIDsOfNames (ItestDual *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	TestDual_Invoke (ItestDual *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static struct disp_obj *	impl_from_ISomethingFromDispatch (ISomethingFromDispatch *iface)
static HRESULT WINAPI	disp_obj_QueryInterface (ISomethingFromDispatch *iface, REFIID iid, void **out)
static ULONG WINAPI	disp_obj_AddRef (ISomethingFromDispatch *iface)
static ULONG WINAPI	disp_obj_Release (ISomethingFromDispatch *iface)
static HRESULT WINAPI	disp_obj_GetTypeInfoCount (ISomethingFromDispatch *iface, UINT *count)
static HRESULT WINAPI	disp_obj_GetTypeInfo (ISomethingFromDispatch *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
static HRESULT WINAPI	disp_obj_GetIDsOfNames (ISomethingFromDispatch *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
static HRESULT WINAPI	disp_obj_Invoke (ISomethingFromDispatch *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *dispparams, VARIANT *result, EXCEPINFO *excepinfo, UINT *errarg)
static HRESULT WINAPI	disp_obj_anotherfn (ISomethingFromDispatch *iface)
static ISomethingFromDispatch *	create_disp_obj (void)
static struct coclass_obj *	impl_from_ICoclass1 (ICoclass1 *iface)
static struct coclass_obj *	impl_from_ICoclass2 (ICoclass2 *iface)
static HRESULT WINAPI	coclass1_QueryInterface (ICoclass1 *iface, REFIID iid, void **out)
static ULONG WINAPI	coclass1_AddRef (ICoclass1 *iface)
static ULONG WINAPI	coclass1_Release (ICoclass1 *iface)
static HRESULT WINAPI	coclass1_GetTypeInfoCount (ICoclass1 *iface, UINT *count)
static HRESULT WINAPI	coclass1_GetTypeInfo (ICoclass1 *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
static HRESULT WINAPI	coclass1_GetIDsOfNames (ICoclass1 *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
static HRESULT WINAPI	coclass1_Invoke (ICoclass1 *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *dispparams, VARIANT *result, EXCEPINFO *excepinfo, UINT *errarg)
static HRESULT WINAPI	coclass1_test (ICoclass1 *iface)
static HRESULT WINAPI	coclass2_QueryInterface (ICoclass2 *iface, REFIID iid, void **out)
static ULONG WINAPI	coclass2_AddRef (ICoclass2 *iface)
static ULONG WINAPI	coclass2_Release (ICoclass2 *iface)
static HRESULT WINAPI	coclass2_GetTypeInfoCount (ICoclass2 *iface, UINT *count)
static HRESULT WINAPI	coclass2_GetTypeInfo (ICoclass2 *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
static HRESULT WINAPI	coclass2_GetIDsOfNames (ICoclass2 *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
static HRESULT WINAPI	coclass2_Invoke (ICoclass2 *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *dispparams, VARIANT *result, EXCEPINFO *excepinfo, UINT *errarg)
static HRESULT WINAPI	coclass2_test (ICoclass2 *iface)
static struct coclass_obj *	create_coclass_obj (void)
static Widget *	impl_from_IWidget (IWidget *iface)
static HRESULT WINAPI	Widget_QueryInterface (IWidget *iface, REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject)
static ULONG WINAPI	Widget_AddRef (IWidget *iface)
static ULONG WINAPI	Widget_Release (IWidget *iface)
static HRESULT WINAPI	Widget_GetTypeInfoCount (IWidget *iface, UINT __RPC_FAR *pctinfo)
static HRESULT WINAPI	Widget_GetTypeInfo (IWidget __RPC_FAR *iface, UINT iTInfo, LCID lcid, ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
static HRESULT WINAPI	Widget_GetIDsOfNames (IWidget __RPC_FAR *iface, REFIID riid, LPOLESTR __RPC_FAR *rgszNames, UINT cNames, LCID lcid, DISPID __RPC_FAR *rgDispId)
static HRESULT WINAPI	Widget_Invoke (IWidget __RPC_FAR *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR *pVarResult, EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr)
static HRESULT WINAPI	Widget_put_Name (IWidget __RPC_FAR *iface, BSTR name)
static HRESULT WINAPI	Widget_get_Name (IWidget __RPC_FAR *iface, BSTR __RPC_FAR *name)
static HRESULT WINAPI	Widget_DoSomething (IWidget __RPC_FAR *iface, double number, BSTR *str1, BSTR str2, VARIANT __RPC_FAR *opt)
static HRESULT WINAPI	Widget_get_State (IWidget __RPC_FAR *iface, STATE __RPC_FAR *state)
static HRESULT WINAPI	Widget_put_State (IWidget __RPC_FAR *iface, STATE state)
static HRESULT WINAPI	Widget_Map (IWidget *iface, BSTR bstrId, BSTR *sValue)
static HRESULT WINAPI	Widget_SetOleColor (IWidget *iface, OLE_COLOR val)
static HRESULT WINAPI	Widget_GetOleColor (IWidget *iface, OLE_COLOR *pVal)
static HRESULT WINAPI	Widget_Clone (IWidget *iface, IWidget **ppVal)
static HRESULT WINAPI	Widget_CloneDispatch (IWidget *iface, IDispatch **ppVal)
static HRESULT WINAPI	Widget_CloneCoclass (IWidget *iface, ApplicationObject2 **ppVal)
static HRESULT WINAPI	Widget_Value (IWidget __RPC_FAR *iface, VARIANT *value, VARIANT *retval)
static HRESULT WINAPI	Widget_VariantArrayPtr (IWidget *iface, SAFEARRAY **values)
static HRESULT WINAPI	Widget_VarArg (IWidget *iface, int numexpect, SAFEARRAY *values)
static HRESULT WINAPI	Widget_Error (IWidget __RPC_FAR *iface)
static HRESULT WINAPI	Widget_CloneInterface (IWidget __RPC_FAR *iface, ISomethingFromDispatch **ppVal)
static HRESULT WINAPI	Widget_put_prop_with_lcid (IWidget *iface, LONG lcid, INT i)
static HRESULT WINAPI	Widget_get_prop_with_lcid (IWidget *iface, LONG lcid, INT *i)
static HRESULT WINAPI	Widget_get_prop_int (IWidget *iface, INT *i)
static HRESULT WINAPI	Widget_get_prop_uint (IWidget *iface, UINT *i)
static HRESULT WINAPI	Widget_ByRefUInt (IWidget *iface, UINT *i)
static HRESULT WINAPI	Widget_put_prop_opt_arg (IWidget *iface, INT opt, INT i)
static HRESULT WINAPI	Widget_put_prop_req_arg (IWidget *iface, INT req, INT i)
static HRESULT WINAPI	Widget_pos_restrict (IWidget *iface, INT *i)
static HRESULT WINAPI	Widget_neg_restrict (IWidget *iface, INT *i)
static HRESULT WINAPI	Widget_VarArg_Run (IWidget *iface, BSTR name, SAFEARRAY *params, VARIANT *result)
static HRESULT WINAPI	Widget_VarArg_Ref_Run (IWidget *iface, BSTR name, SAFEARRAY **params, VARIANT *result)
static HRESULT WINAPI	Widget_basetypes_in (IWidget *iface, signed char c, short s, int i, hyper h, unsigned char uc, unsigned short us, unsigned int ui, MIDL_uhyper uh, float f, double d, STATE st)
static HRESULT WINAPI	Widget_basetypes_out (IWidget *iface, signed char *c, short *s, int *i, hyper *h, unsigned char *uc, unsigned short *us, unsigned int *ui, MIDL_uhyper *uh, float *f, double *d, STATE *st)
static HRESULT WINAPI	Widget_float_abi (IWidget *iface, float f, double d, int i, float f2, double d2)
static HRESULT WINAPI	Widget_int_ptr (IWidget *iface, int *in, int *out, int *in_out)
static HRESULT WINAPI	Widget_int_ptr_ptr (IWidget *iface, int **in, int **out, int **in_out)
static void	check_iface_marshal (IUnknown *unk, IDispatch *disp, ISomethingFromDispatch *sfd)
static HRESULT WINAPI	Widget_iface_in (IWidget *iface, IUnknown *unk, IDispatch *disp, ISomethingFromDispatch *sfd)
static HRESULT WINAPI	Widget_iface_out (IWidget *iface, IUnknown **unk, IDispatch **disp, ISomethingFromDispatch **sfd)
static HRESULT WINAPI	Widget_iface_ptr (IWidget *iface, ISomethingFromDispatch **in, ISomethingFromDispatch **out, ISomethingFromDispatch **in_out)
static HRESULT WINAPI	Widget_bstr (IWidget *iface, BSTR in, BSTR *out, BSTR *in_ptr, BSTR *in_out)
static HRESULT WINAPI	Widget_variant (IWidget *iface, VARIANT in, VARIANT *out, VARIANT *in_ptr, VARIANT *in_out)
static SAFEARRAY *	make_safearray (ULONG len)
static void	check_safearray (SAFEARRAY *sa, LONG expect)
static HRESULT WINAPI	Widget_safearray (IWidget *iface, SAFEARRAY *in, SAFEARRAY **out, SAFEARRAY **in_ptr, SAFEARRAY **in_out)
static HRESULT WINAPI	Widget_mystruct (IWidget *iface, MYSTRUCT in, MYSTRUCT *out, MYSTRUCT *in_ptr, MYSTRUCT *in_out)
static HRESULT WINAPI	Widget_mystruct_ptr_ptr (IWidget *iface, MYSTRUCT **in)
static HRESULT WINAPI	Widget_thin_struct (IWidget *iface, struct thin in)
static HRESULT WINAPI	Widget_rect (IWidget *iface, RECT in, RECT *out, RECT *in_ptr, RECT *in_out)
static HRESULT WINAPI	Widget_complex_struct (IWidget *iface, struct complex in)
static HRESULT WINAPI	Widget_array (IWidget *iface, array_t in, array_t out, array_t in_out)
static HRESULT WINAPI	Widget_variant_array (IWidget *iface, VARIANT in[2], VARIANT out[2], VARIANT in_out[2])
static HRESULT WINAPI	Widget_mystruct_array (IWidget *iface, MYSTRUCT in[2])
static HRESULT WINAPI	Widget_myint (IWidget *iface, myint_t val, myint_t *ptr, myint_t **ptr_ptr)
static HRESULT WINAPI	Widget_Coclass (IWidget *iface, Coclass1 *class1, Coclass2 *class2, Coclass3 *class3)
static HRESULT WINAPI	Widget_Coclass_ptr (IWidget *iface, Coclass1 **in, Coclass1 **out, Coclass1 **in_out)
static HRESULT WINAPI	StaticWidget_QueryInterface (IStaticWidget *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	StaticWidget_AddRef (IStaticWidget *iface)
static ULONG WINAPI	StaticWidget_Release (IStaticWidget *iface)
static HRESULT WINAPI	StaticWidget_GetTypeInfoCount (IStaticWidget *iface, UINT *pctinfo)
static HRESULT WINAPI	StaticWidget_GetTypeInfo (IStaticWidget *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	StaticWidget_GetIDsOfNames (IStaticWidget *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	StaticWidget_Invoke (IStaticWidget *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	StaticWidget_TestDual (IStaticWidget *iface, ItestDual *p)
static HRESULT WINAPI	StaticWidget_TestSecondIface (IStaticWidget *iface, ITestSecondIface *p)
static KindaEnum *	impl_from_IKindaEnumWidget (IKindaEnumWidget *iface)
static HRESULT	register_current_module_typelib (void)
static ITypeInfo *	get_type_info (REFIID riid)
static IWidget *	Widget_Create (void)
static HRESULT WINAPI	KindaEnum_QueryInterface (IKindaEnumWidget *iface, REFIID riid, void __RPC_FAR *__RPC_FAR *ppvObject)
static ULONG WINAPI	KindaEnum_AddRef (IKindaEnumWidget *iface)
static ULONG WINAPI	KindaEnum_Release (IKindaEnumWidget *iface)
static HRESULT WINAPI	KindaEnum_Next (IKindaEnumWidget *iface, IWidget __RPC_FAR *__RPC_FAR *widget)
static HRESULT WINAPI	KindaEnum_Count (IKindaEnumWidget *iface, ULONG __RPC_FAR *count)
static HRESULT WINAPI	KindaEnum_Reset (IKindaEnumWidget *iface)
static HRESULT WINAPI	KindaEnum_Clone (IKindaEnumWidget *iface, IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
static IKindaEnumWidget *	KindaEnumWidget_Create (void)
static HRESULT WINAPI	NonOleAutomation_QueryInterface (INonOleAutomation *iface, REFIID riid, void **ppv)
static ULONG WINAPI	NonOleAutomation_AddRef (INonOleAutomation *iface)
static ULONG WINAPI	NonOleAutomation_Release (INonOleAutomation *iface)
static BSTR WINAPI	NonOleAutomation_BstrRet (INonOleAutomation *iface)
static HRESULT WINAPI	NonOleAutomation_Error (INonOleAutomation *iface)
static ITypeInfo *	NonOleAutomation_GetTypeInfo (void)
static void	test_marshal_basetypes (IWidget *widget, IDispatch *disp)
static void	test_marshal_pointer (IWidget *widget, IDispatch *disp)
static void	test_marshal_iface (IWidget *widget, IDispatch *disp)
static void	test_marshal_bstr (IWidget *widget, IDispatch *disp)
static void	test_marshal_variant (IWidget *widget, IDispatch *disp)
static void	test_marshal_safearray (IWidget *widget, IDispatch *disp)
static void	test_marshal_struct (IWidget *widget, IDispatch *disp)
static void	test_marshal_array (IWidget *widget, IDispatch *disp)
static void	test_marshal_coclass (IWidget *widget, IDispatch *disp)
static void	test_typelibmarshal (void)
static void	test_DispCallFunc (void)
static void	test_StaticWidget (void)
static void	test_libattr (void)
static void	test_external_connection (void)
static void	test_marshal_dispinterface (void)
	START_TEST (tmarshal)

Variables
static	LPVARIANT
static const WCHAR	test_bstr1 [] = {'f','o','o',0,'b','a','r'}
static const WCHAR	test_bstr2 [] = {'t','e','s','t',0}
static const WCHAR	test_bstr3 [] = {'q','u','x',0}
static const WCHAR	test_bstr4 [] = {'a','b','c',0}
static const MYSTRUCT	test_mystruct1 = {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432), {0,1,2,3,4,5,6,7}}
static const MYSTRUCT	test_mystruct2 = {0x91827364, ULL_CONST(0x88776655, 0x44332211), {3,6,1,4,0,1,3,0}}
static const MYSTRUCT	test_mystruct3 = {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415), {9,2,4,5,6,5,1,3}}
static const MYSTRUCT	test_mystruct4 = {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425), {0,4,6,7,3,6,7,4}}
static const MYSTRUCT	test_mystruct5 = {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435), {1,6,7,3,8,4,6,5}}
static const MYSTRUCT	test_mystruct6 = {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445), {3,6,5,3,4,8,0,9}}
static const MYSTRUCT	test_mystruct7 = {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455), {1,8,4,4,4,2,3,1}}
static const struct thin	test_thin_struct = {-456, 78}
static const RECT	test_rect1 = {1,2,3,4}
static const RECT	test_rect2 = {5,6,7,8}
static const RECT	test_rect3 = {9,10,11,12}
static const RECT	test_rect4 = {13,14,15,16}
static const RECT	test_rect5 = {17,18,19,20}
static const RECT	test_rect6 = {21,22,23,24}
static const RECT	test_rect7 = {25,26,27,28}
static const array_t	test_array1 = {1,2,3,4}
static const array_t	test_array2 = {5,6,7,8}
static const array_t	test_array3 = {9,10,11,12}
static const array_t	test_array4 = {13,14,15,16}
static const array_t	test_array5 = {17,18,19,20}
static const array_t	test_array6 = {21,22,23,24}
static int	external_connections
static BOOL	expect_last_release_closes
static const IExternalConnectionVtbl	ExternalConnectionVtbl
static IExternalConnection	ExternalConnection = { &ExternalConnectionVtbl }
static ItestDual	TestDual = { &TestDualVtbl }
static ItestDual	TestDualDisp = { &TestDualVtbl }
static const ITestSecondIfaceVtbl	TestSecondIfaceVtbl
static ITestSecondIface	TestSecondIface = { &TestSecondIfaceVtbl }
static ITestSecondDispVtbl	TestSecondDispVtbl
static ITestSecondDisp	TestSecondDisp = { &TestSecondDispVtbl }
static ItestDualVtbl	TestDualVtbl
static const ISomethingFromDispatchVtbl	disp_obj_vtbl
static const ICoclass1Vtbl	coclass1_vtbl
static const ICoclass2Vtbl	coclass2_vtbl
static int	testmode
static const struct IWidgetVtbl	Widget_VTable
static const IStaticWidgetVtbl	StaticWidgetVtbl
static IStaticWidget	StaticWidget = { &StaticWidgetVtbl }
static const IKindaEnumWidgetVtbl	KindaEnumWidget_VTable
static INonOleAutomationVtbl	NonOleAutomation_VTable
static INonOleAutomation	NonOleAutomation = { &NonOleAutomation_VTable }

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file tmarshal.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 23 of file tmarshal.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 tmarshal.c.

release_iface

#define release_iface

(

a

)

release_iface_(__LINE__, a)

Definition at line 43 of file tmarshal.c.

RELEASEMARSHALDATA

#define RELEASEMARSHALDATA   WM_USER

Definition at line 78 of file tmarshal.c.

ULL_CONST

#define ULL_CONST	(		dw1,
			dw2
	)		((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)

Definition at line 46 of file tmarshal.c.

Typedef Documentation

KindaEnum

typedef struct KindaEnum KindaEnum

Widget

typedef struct Widget Widget

Function Documentation

check_iface_marshal()

static void check_iface_marshal ( IUnknown *  unk, IDispatch *  disp, ISomethingFromDispatch *  sfd  )

static

Definition at line 1212 of file tmarshal.c.

{
    ISomethingFromDispatch *sfd2;
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    hr = IUnknown_QueryInterface(unk, &IID_ISomethingFromDispatch, (void **)&sfd2);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ISomethingFromDispatch_Release(sfd2);
 
    hr = IDispatch_GetTypeInfo(disp, 0xdeadbeef, 0, &typeinfo);
    ok(hr == 0xbeefdead, "Got hr %#x.\n", hr);
 
    hr = ISomethingFromDispatch_anotherfn(sfd);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
}

Referenced by test_marshal_iface(), and Widget_iface_in().

check_safearray()

static void check_safearray ( SAFEARRAY *  sa, LONG  expect  )

static

Definition at line 1367 of file tmarshal.c.

{
    LONG len, i, *data;
    HRESULT hr;
 
    hr = SafeArrayGetUBound(sa, 1, &len);
    len++;
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(len == expect, "Expected len %d, got %d.\n", expect, len);
 
    hr = SafeArrayAccessData(sa, (void **)&data);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    for (i = 0; i < len; ++i)
        ok(data[i] == len + i, "Expected data %d at %d, got %d.\n", len + i, i, data[i]);
 
    SafeArrayUnaccessData(sa);
}

Referenced by test_marshal_safearray(), and Widget_safearray().

coclass1_AddRef()

static ULONG WINAPI coclass1_AddRef ( ICoclass1 *  iface )

static

Definition at line 532 of file tmarshal.c.

{
    struct coclass_obj *obj = impl_from_ICoclass1(iface);
    return ++obj->ref;
}

coclass1_GetIDsOfNames()

static HRESULT WINAPI coclass1_GetIDsOfNames ( ICoclass1 *  iface, REFIID  iid, LPOLESTR *  names, UINT  count, LCID  lcid, DISPID *  ids  )

static

Definition at line 560 of file tmarshal.c.

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

coclass1_GetTypeInfo()

static HRESULT WINAPI coclass1_GetTypeInfo ( ICoclass1 *  iface, UINT  index, LCID  lcid, ITypeInfo **  typeinfo  )

static

Definition at line 553 of file tmarshal.c.

{
    ok(index == 0xdeadbeef, "Got unexpected index %#x.\n", index);
    return 0xbeefdead;
}

coclass1_GetTypeInfoCount()

static HRESULT WINAPI coclass1_GetTypeInfoCount ( ICoclass1 *  iface, UINT *  count  )

static

Definition at line 547 of file tmarshal.c.

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

coclass1_Invoke()

static HRESULT WINAPI coclass1_Invoke ( ICoclass1 *  iface, DISPID  id, REFIID  iid, LCID  lcid, WORD  flags, DISPPARAMS *  dispparams, VARIANT *  result, EXCEPINFO *  excepinfo, UINT *  errarg  )

static

Definition at line 567 of file tmarshal.c.

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

coclass1_QueryInterface()

static HRESULT WINAPI coclass1_QueryInterface ( ICoclass1 *  iface, REFIID  iid, void **  out  )

static

Definition at line 509 of file tmarshal.c.

{
    struct coclass_obj *obj = impl_from_ICoclass1(iface);
 
    if (IsEqualGUID(iid, &IID_IUnknown)
            || IsEqualGUID(iid, &IID_IDispatch)
            || IsEqualGUID(iid, &IID_ICoclass1))
    {
        *out = iface;
        ICoclass1_AddRef(iface);
        return S_OK;
    }
    else if (IsEqualGUID(iid, &IID_ICoclass2))
    {
        *out = &obj->ICoclass2_iface;
        ICoclass2_AddRef(*out);
        return S_OK;
    }
 
    *out = NULL;
    return E_NOINTERFACE;
}

coclass1_Release()

static ULONG WINAPI coclass1_Release ( ICoclass1 *  iface )

static

Definition at line 538 of file tmarshal.c.

{
    struct coclass_obj *obj = impl_from_ICoclass1(iface);
    LONG ref = --obj->ref;
    if (!ref)
        CoTaskMemFree(obj);
    return ref;
}

coclass1_test()

static HRESULT WINAPI coclass1_test ( ICoclass1 *  iface )

static

Definition at line 574 of file tmarshal.c.

{
    return 1;
}

coclass2_AddRef()

static ULONG WINAPI coclass2_AddRef ( ICoclass2 *  iface )

static

Definition at line 585 of file tmarshal.c.

{
    struct coclass_obj *obj = impl_from_ICoclass2(iface);
    return ICoclass1_AddRef(&obj->ICoclass1_iface);
}

coclass2_GetIDsOfNames()

static HRESULT WINAPI coclass2_GetIDsOfNames ( ICoclass2 *  iface, REFIID  iid, LPOLESTR *  names, UINT  count, LCID  lcid, DISPID *  ids  )

static

Definition at line 610 of file tmarshal.c.

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

coclass2_GetTypeInfo()

static HRESULT WINAPI coclass2_GetTypeInfo ( ICoclass2 *  iface, UINT  index, LCID  lcid, ITypeInfo **  typeinfo  )

static

Definition at line 603 of file tmarshal.c.

{
    ok(index == 0xdeadbeef, "Got unexpected index %#x.\n", index);
    return 0xbeefdead;
}

coclass2_GetTypeInfoCount()

static HRESULT WINAPI coclass2_GetTypeInfoCount ( ICoclass2 *  iface, UINT *  count  )

static

Definition at line 597 of file tmarshal.c.

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

coclass2_Invoke()

static HRESULT WINAPI coclass2_Invoke ( ICoclass2 *  iface, DISPID  id, REFIID  iid, LCID  lcid, WORD  flags, DISPPARAMS *  dispparams, VARIANT *  result, EXCEPINFO *  excepinfo, UINT *  errarg  )

static

Definition at line 617 of file tmarshal.c.

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

coclass2_QueryInterface()

static HRESULT WINAPI coclass2_QueryInterface ( ICoclass2 *  iface, REFIID  iid, void **  out  )

static

Definition at line 579 of file tmarshal.c.

{
    struct coclass_obj *obj = impl_from_ICoclass2(iface);
    return ICoclass1_QueryInterface(&obj->ICoclass1_iface, iid, out);
}

coclass2_Release()

static ULONG WINAPI coclass2_Release ( ICoclass2 *  iface )

static

Definition at line 591 of file tmarshal.c.

{
    struct coclass_obj *obj = impl_from_ICoclass2(iface);
    return ICoclass1_Release(&obj->ICoclass1_iface);
}

coclass2_test()

static HRESULT WINAPI coclass2_test ( ICoclass2 *  iface )

static

Definition at line 624 of file tmarshal.c.

{
    return 2;
}

create_coclass_obj()

static struct coclass_obj * create_coclass_obj ( void  )

static

Definition at line 653 of file tmarshal.c.

{
    struct coclass_obj *obj = CoTaskMemAlloc(sizeof(*obj));
    obj->ICoclass1_iface.lpVtbl = &coclass1_vtbl;
    obj->ICoclass2_iface.lpVtbl = &coclass2_vtbl;
    obj->ref = 1;
    return obj;
};

Referenced by test_marshal_coclass(), and Widget_Coclass_ptr().

create_disp_obj()

static ISomethingFromDispatch * create_disp_obj ( void  )

static

Definition at line 484 of file tmarshal.c.

{
    struct disp_obj *obj = CoTaskMemAlloc(sizeof(*obj));
    obj->ISomethingFromDispatch_iface.lpVtbl = &disp_obj_vtbl;
    obj->ref = 1;
    return &obj->ISomethingFromDispatch_iface;
}

Referenced by test_marshal_dispinterface(), test_marshal_iface(), test_marshal_struct(), Widget_iface_out(), Widget_iface_ptr(), and Widget_variant_array().

disp_obj_AddRef()

static ULONG WINAPI disp_obj_AddRef ( ISomethingFromDispatch *  iface )

static

Definition at line 425 of file tmarshal.c.

{
    struct disp_obj *obj = impl_from_ISomethingFromDispatch(iface);
    return ++obj->ref;
}

disp_obj_anotherfn()

static HRESULT WINAPI disp_obj_anotherfn ( ISomethingFromDispatch *  iface )

static

Definition at line 467 of file tmarshal.c.

{
    return 0x01234567;
}

disp_obj_GetIDsOfNames()

static HRESULT WINAPI disp_obj_GetIDsOfNames ( ISomethingFromDispatch *  iface, REFIID  iid, LPOLESTR *  names, UINT  count, LCID  lcid, DISPID *  ids  )

static

Definition at line 453 of file tmarshal.c.

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

disp_obj_GetTypeInfo()

static HRESULT WINAPI disp_obj_GetTypeInfo ( ISomethingFromDispatch *  iface, UINT  index, LCID  lcid, ITypeInfo **  typeinfo  )

static

Definition at line 446 of file tmarshal.c.

{
    ok(index == 0xdeadbeef, "Got unexpected index %#x.\n", index);
    return 0xbeefdead;
}

disp_obj_GetTypeInfoCount()

static HRESULT WINAPI disp_obj_GetTypeInfoCount ( ISomethingFromDispatch *  iface, UINT *  count  )

static

Definition at line 440 of file tmarshal.c.

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

disp_obj_Invoke()

static HRESULT WINAPI disp_obj_Invoke ( ISomethingFromDispatch *  iface, DISPID  id, REFIID  iid, LCID  lcid, WORD  flags, DISPPARAMS *  dispparams, VARIANT *  result, EXCEPINFO *  excepinfo, UINT *  errarg  )

static

Definition at line 460 of file tmarshal.c.

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

disp_obj_QueryInterface()

static HRESULT WINAPI disp_obj_QueryInterface ( ISomethingFromDispatch *  iface, REFIID  iid, void **  out  )

static

Definition at line 410 of file tmarshal.c.

{
    if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IDispatch)
            || IsEqualGUID(iid, &IID_ISomethingFromDispatch)
            || IsEqualGUID(iid, &DIID_ItestIF4))
    {
        *out = iface;
        ISomethingFromDispatch_AddRef(iface);
        return S_OK;
    }
 
    *out = NULL;
    return E_NOINTERFACE;
}

disp_obj_Release()

static ULONG WINAPI disp_obj_Release ( ISomethingFromDispatch *  iface )

static

Definition at line 431 of file tmarshal.c.

{
    struct disp_obj *obj = impl_from_ISomethingFromDispatch(iface);
    LONG ref = --obj->ref;
    if (!ref)
        CoTaskMemFree(obj);
    return ref;
}

end_host_object()

static void end_host_object ( DWORD  tid, HANDLE  thread  )

static

Definition at line 172 of file tmarshal.c.

{
    BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
    ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
    /* be careful of races - don't return until hosting thread has terminated */
    WaitForSingleObject(thread, INFINITE);
    CloseHandle(thread);
}

Referenced by test_external_connection(), test_marshal_dispinterface(), and test_typelibmarshal().

ExternalConnection_AddConnection()

static DWORD WINAPI ExternalConnection_AddConnection ( IExternalConnection *  iface, DWORD  extconn, DWORD  reserved  )

static

Definition at line 201 of file tmarshal.c.

{
    trace("add connection\n");
 
    ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
    ok(!reserved, "reserved = %x\n", reserved);
    return ++external_connections;
}

ExternalConnection_AddRef()

static ULONG WINAPI ExternalConnection_AddRef ( IExternalConnection *  iface )

static

Definition at line 191 of file tmarshal.c.

{
    return 2;
}

ExternalConnection_QueryInterface()

static HRESULT WINAPI ExternalConnection_QueryInterface ( IExternalConnection *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 184 of file tmarshal.c.

{
    ok(0, "unexpected call\n");
    *ppv = NULL;
    return E_NOINTERFACE;
}

ExternalConnection_Release()

static ULONG WINAPI ExternalConnection_Release ( IExternalConnection *  iface )

static

Definition at line 196 of file tmarshal.c.

{
    return 1;
}

ExternalConnection_ReleaseConnection()

static DWORD WINAPI ExternalConnection_ReleaseConnection ( IExternalConnection *  iface, DWORD  extconn, DWORD  reserved, BOOL  fLastReleaseCloses  )

static

Definition at line 210 of file tmarshal.c.

{
    trace("release connection\n");
 
    ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
    ok(!reserved, "reserved = %x\n", reserved);
 
    ok(fLastReleaseCloses == expect_last_release_closes, "fLastReleaseCloses = %x, expected %x\n",
       fLastReleaseCloses, expect_last_release_closes);
    return --external_connections;
}

get_type_info()

static ITypeInfo * get_type_info ( REFIID  riid )

static

Definition at line 1743 of file tmarshal.c.

{
    ITypeInfo *pTypeInfo;
    ITypeLib *pTypeLib;
    HRESULT hr;
 
    hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
    ok_ole_success(hr, LoadRegTypeLib);
    if (FAILED(hr))
        return NULL;
 
    hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
    ITypeLib_Release(pTypeLib);
    ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
    if (FAILED(hr))
        return NULL;
 
    return pTypeInfo;
}

Referenced by test_StaticWidget(), and Widget_Create().

host_object_proc()

static DWORD CALLBACK host_object_proc ( LPVOID  p )

static

Definition at line 90 of file tmarshal.c.

{
    struct host_object_data *data = p;
    HRESULT hr;
    MSG msg;
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    if (data->filter)
    {
        IMessageFilter * prev_filter = NULL;
        hr = CoRegisterMessageFilter(data->filter, &prev_filter);
        if (prev_filter) IMessageFilter_Release(prev_filter);
        ok_ole_success(hr, CoRegisterMessageFilter);
    }
 
    hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
    ok_ole_success(hr, CoMarshalInterface);
 
    /* force the message queue to be created before signaling parent thread */
    PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 
    SetEvent(data->marshal_event);
 
    while (GetMessageA(&msg, NULL, 0, 0))
    {
        if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
        {
            trace("releasing marshal data\n");
            CoReleaseMarshalData(data->stream);
            SetEvent((HANDLE)msg.lParam);
        }
        else
            DispatchMessageA(&msg);
    }
 
    HeapFree(GetProcessHeap(), 0, data);
 
    CoUninitialize();
 
    return hr;
}

Referenced by start_host_object2().

HRESULT()

static HRESULT ( WINAPI *  pVarAdd )

static

impl_from_ICoclass1()

static struct coclass_obj * impl_from_ICoclass1 ( ICoclass1 *  iface )

inlinestatic

Definition at line 499 of file tmarshal.c.

{
    return CONTAINING_RECORD(iface, struct coclass_obj, ICoclass1_iface);
}

Referenced by coclass1_AddRef(), coclass1_QueryInterface(), and coclass1_Release().

impl_from_ICoclass2()

static struct coclass_obj * impl_from_ICoclass2 ( ICoclass2 *  iface )

inlinestatic

Definition at line 504 of file tmarshal.c.

{
    return CONTAINING_RECORD(iface, struct coclass_obj, ICoclass2_iface);
}

Referenced by coclass2_AddRef(), coclass2_QueryInterface(), and coclass2_Release().

impl_from_IKindaEnumWidget()

static KindaEnum * impl_from_IKindaEnumWidget ( IKindaEnumWidget *  iface )

inlinestatic

Definition at line 1719 of file tmarshal.c.

{
    return CONTAINING_RECORD(iface, KindaEnum, IKindaEnumWidget_iface);
}

Referenced by KindaEnum_AddRef(), and KindaEnum_Release().

impl_from_ISomethingFromDispatch()

static struct disp_obj * impl_from_ISomethingFromDispatch ( ISomethingFromDispatch *  iface )

inlinestatic

Definition at line 405 of file tmarshal.c.

{
    return CONTAINING_RECORD(iface, struct disp_obj, ISomethingFromDispatch_iface);
}

Referenced by disp_obj_AddRef(), and disp_obj_Release().

impl_from_IWidget()

static Widget * impl_from_IWidget ( IWidget *  iface )

inlinestatic

Definition at line 671 of file tmarshal.c.

{
    return CONTAINING_RECORD(iface, Widget, IWidget_iface);
}

Referenced by Widget_AddRef(), Widget_GetIDsOfNames(), Widget_GetTypeInfo(), Widget_GetTypeInfoCount(), Widget_Invoke(), and Widget_Release().

KindaEnum_AddRef()

static ULONG WINAPI KindaEnum_AddRef ( IKindaEnumWidget *  iface )

static

Definition at line 1810 of file tmarshal.c.

{
    KindaEnum *This = impl_from_IKindaEnumWidget(iface);
 
    return InterlockedIncrement(&This->refs);
}

KindaEnum_Clone()

static HRESULT WINAPI KindaEnum_Clone ( IKindaEnumWidget *  iface, IKindaEnumWidget __RPC_FAR *__RPC_FAR *  ppenum  )

static

Definition at line 1857 of file tmarshal.c.

{
    return E_NOTIMPL;
}

KindaEnum_Count()

static HRESULT WINAPI KindaEnum_Count ( IKindaEnumWidget *  iface, ULONG __RPC_FAR *  count  )

static

Definition at line 1844 of file tmarshal.c.

{
    return E_NOTIMPL;
}

KindaEnum_Next()

static HRESULT WINAPI KindaEnum_Next ( IKindaEnumWidget *  iface, IWidget __RPC_FAR *__RPC_FAR *  widget  )

static

Definition at line 1833 of file tmarshal.c.

{
    *widget = Widget_Create();
    if (*widget)
        return S_OK;
    else
        return E_OUTOFMEMORY;
}

KindaEnum_QueryInterface()

static HRESULT WINAPI KindaEnum_QueryInterface ( IKindaEnumWidget *  iface, REFIID  riid, void __RPC_FAR *__RPC_FAR *  ppvObject  )

static

Definition at line 1792 of file tmarshal.c.

{
    if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
    {
        IKindaEnumWidget_AddRef(iface);
        *ppvObject = iface;
        return S_OK;
    }
    else
    {
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
}

KindaEnum_Release()

static ULONG WINAPI KindaEnum_Release ( IKindaEnumWidget *  iface )

static

Definition at line 1818 of file tmarshal.c.

{
    KindaEnum *This = impl_from_IKindaEnumWidget(iface);
    ULONG refs = InterlockedDecrement(&This->refs);
    if (!refs)
    {
        memset(This, 0xcc, sizeof(*This));
        HeapFree(GetProcessHeap(), 0, This);
        trace("KindaEnumWidget destroyed!\n");
    }
 
    return refs;
}

KindaEnum_Reset()

static HRESULT WINAPI KindaEnum_Reset ( IKindaEnumWidget *  iface )

static

Definition at line 1851 of file tmarshal.c.

{
    return E_NOTIMPL;
}

KindaEnumWidget_Create()

static IKindaEnumWidget * KindaEnumWidget_Create ( void  )

static

Definition at line 1875 of file tmarshal.c.

{
    KindaEnum *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return NULL;
    This->IKindaEnumWidget_iface.lpVtbl = &KindaEnumWidget_VTable;
    This->refs = 1;
    return &This->IKindaEnumWidget_iface;
}

Referenced by test_typelibmarshal().

make_safearray()

static SAFEARRAY * make_safearray ( ULONG  len )

static

Definition at line 1354 of file tmarshal.c.

{
    SAFEARRAY *sa = SafeArrayCreateVector(VT_I4, 0, len);
    int i, *data;
 
    SafeArrayAccessData(sa, (void **)&data);
    for (i = 0; i < len; ++i)
        data[i] = len + i;
    SafeArrayUnaccessData(sa);
 
    return sa;
}

Referenced by test_marshal_safearray(), and Widget_safearray().

NonOleAutomation_AddRef()

static ULONG WINAPI NonOleAutomation_AddRef ( INonOleAutomation *  iface )

static

Definition at line 1897 of file tmarshal.c.

{
    return 2;
}

NonOleAutomation_BstrRet()

static BSTR WINAPI NonOleAutomation_BstrRet ( INonOleAutomation *  iface )

static

Definition at line 1907 of file tmarshal.c.

{
    static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
    return SysAllocString(wszTestString);
}

NonOleAutomation_Error()

static HRESULT WINAPI NonOleAutomation_Error ( INonOleAutomation *  iface )

static

Definition at line 1913 of file tmarshal.c.

{
    return E_NOTIMPL;
}

NonOleAutomation_GetTypeInfo()

static ITypeInfo * NonOleAutomation_GetTypeInfo ( void  )

static

Definition at line 1929 of file tmarshal.c.

{
    ITypeLib *pTypeLib;
    HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
    ok_ole_success(hr, LoadRegTypeLib);
    if (SUCCEEDED(hr))
    {
        ITypeInfo *pTypeInfo;
        hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
        ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
        ITypeLib_Release(pTypeLib);
        return pTypeInfo;
    }
    return NULL;
}

Referenced by test_typelibmarshal().

NonOleAutomation_QueryInterface()

static HRESULT WINAPI NonOleAutomation_QueryInterface ( INonOleAutomation *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1886 of file tmarshal.c.

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

NonOleAutomation_Release()

static ULONG WINAPI NonOleAutomation_Release ( INonOleAutomation *  iface )

static

Definition at line 1902 of file tmarshal.c.

{
    return 1;
}

register_current_module_typelib()

static HRESULT register_current_module_typelib ( void  )

static

Definition at line 1724 of file tmarshal.c.

{
    WCHAR path[MAX_PATH];
    CHAR pathA[MAX_PATH];
    HRESULT hr;
    ITypeLib *typelib;
 
    GetModuleFileNameA(NULL, pathA, MAX_PATH);
    MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
 
    hr = LoadTypeLib(path, &typelib);
    if (SUCCEEDED(hr))
    {
        hr = RegisterTypeLib(typelib, path, NULL);
        ITypeLib_Release(typelib);
    }
    return hr;
}

Referenced by START_TEST().

release_iface_()

static void release_iface_ ( unsigned int  line, void *  iface  )

inlinestatic

Definition at line 37 of file tmarshal.c.

{
    ULONG ref = IUnknown_Release((IUnknown *)iface);
    ok_(__FILE__, line)(!ref, "Got outstanding refcount %d.\n", ref);
    if (ref == 1) IUnknown_Release((IUnknown *)iface);
}

start_host_object()

static DWORD start_host_object ( IStream *  stream, REFIID  riid, IUnknown *  object, MSHLFLAGS  marshal_flags, HANDLE *  thread  )

static

Definition at line 155 of file tmarshal.c.

{
    return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
}

Referenced by test_external_connection(), test_marshal_dispinterface(), and test_typelibmarshal().

start_host_object2()

static DWORD start_host_object2 ( IStream *  stream, REFIID  riid, IUnknown *  object, MSHLFLAGS  marshal_flags, IMessageFilter *  filter, HANDLE *  thread  )

static

Definition at line 133 of file tmarshal.c.

{
    DWORD tid = 0;
    HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
    struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 
    data->stream = stream;
    data->iid = *riid;
    data->object = object;
    data->marshal_flags = marshal_flags;
    data->marshal_event = marshal_event;
    data->filter = filter;
 
    *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 
    /* wait for marshaling to complete before returning */
    WaitForSingleObject(marshal_event, INFINITE);
    CloseHandle(marshal_event);
 
    return tid;
}

Referenced by start_host_object().

START_TEST()

START_TEST

(

tmarshal

)

Definition at line 3680 of file tmarshal.c.

{
    HRESULT hr;
    HANDLE hOleaut32 = GetModuleHandleA("oleaut32.dll");
    pVarAdd = (void*)GetProcAddress(hOleaut32, "VarAdd");
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    hr = register_current_module_typelib();
    if (FAILED(hr))
    {
        CoUninitialize();
        win_skip("Registration of the test typelib failed, skipping tests\n");
        return;
    }
 
    test_typelibmarshal();
    test_DispCallFunc();
    test_StaticWidget();
    test_libattr();
    test_external_connection();
    test_marshal_dispinterface();
 
    hr = UnRegisterTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL,
                           sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
    ok_ole_success(hr, UnRegisterTypeLib);
 
    CoUninitialize();
}

StaticWidget_AddRef()

static ULONG WINAPI StaticWidget_AddRef ( IStaticWidget *  iface )

static

Definition at line 1647 of file tmarshal.c.

{
    return 2;
}

StaticWidget_GetIDsOfNames()

static HRESULT WINAPI StaticWidget_GetIDsOfNames ( IStaticWidget *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 1670 of file tmarshal.c.

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

StaticWidget_GetTypeInfo()

static HRESULT WINAPI StaticWidget_GetTypeInfo ( IStaticWidget *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 1663 of file tmarshal.c.

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

StaticWidget_GetTypeInfoCount()

static HRESULT WINAPI StaticWidget_GetTypeInfoCount ( IStaticWidget *  iface, UINT *  pctinfo  )

static

Definition at line 1657 of file tmarshal.c.

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

StaticWidget_Invoke()

static HRESULT WINAPI StaticWidget_Invoke ( IStaticWidget *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 1677 of file tmarshal.c.

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

StaticWidget_QueryInterface()

static HRESULT WINAPI StaticWidget_QueryInterface ( IStaticWidget *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1634 of file tmarshal.c.

{
    if (IsEqualIID(riid, &IID_IStaticWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
    {
        IStaticWidget_AddRef(iface);
        *ppvObject = iface;
        return S_OK;
    }
 
    *ppvObject = NULL;
    return E_NOINTERFACE;
}

StaticWidget_Release()

static ULONG WINAPI StaticWidget_Release ( IStaticWidget *  iface )

static

Definition at line 1652 of file tmarshal.c.

{
    return 1;
}

StaticWidget_TestDual()

static HRESULT WINAPI StaticWidget_TestDual ( IStaticWidget *  iface, ItestDual *  p  )

static

Definition at line 1685 of file tmarshal.c.

{
    trace("TestDual()\n");
    ok(p == &TestDual, "wrong ItestDual\n");
    return S_OK;
}

StaticWidget_TestSecondIface()

static HRESULT WINAPI StaticWidget_TestSecondIface ( IStaticWidget *  iface, ITestSecondIface *  p  )

static

Definition at line 1692 of file tmarshal.c.

{
    trace("TestSecondIface()\n");
    ok(p == &TestSecondIface, "wrong ItestSecondIface\n");
    return S_OK;
}

test_DispCallFunc()

static void test_DispCallFunc ( void  )

static

Definition at line 3437 of file tmarshal.c.

{
    static const WCHAR szEmpty[] = { 0 };
    VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
    VARIANTARG vararg[4];
    VARIANTARG varref;
    VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
    VARIANTARG varresult;
    HRESULT hr;
    IWidget *pWidget = Widget_Create();
    V_VT(&vararg[0]) = VT_R8;
    V_R8(&vararg[0]) = 3.141;
    V_VT(&vararg[1]) = VT_BSTR;
    V_BSTRREF(&vararg[1]) = CoTaskMemAlloc(sizeof(BSTR));
    V_VT(&vararg[2]) = VT_BSTR;
    V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
    V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
    V_VARIANTREF(&vararg[3]) = &varref;
    V_VT(&varref) = VT_ERROR;
    V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
    VariantInit(&varresult);
    hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
    ok_ole_success(hr, DispCallFunc);
    VariantClear(&varresult);
    SysFreeString(*V_BSTRREF(&vararg[1]));
    CoTaskMemFree(V_BSTRREF(&vararg[1]));
    VariantClear(&vararg[2]);
    IWidget_Release(pWidget);
}

Referenced by START_TEST().

test_external_connection()

static void test_external_connection ( void  )

static

Definition at line 3532 of file tmarshal.c.

{
    IStream *stream, *stream2;
    ITestSecondDisp *second;
    ItestDual *iface;
    HANDLE thread;
    DWORD tid;
    HRESULT hres;
 
    static const LARGE_INTEGER zero;
 
    trace("Testing IExternalConnection...\n");
 
    external_connections = 0;
 
    /* Marshaling an interface increases external connection count. */
    expect_last_release_closes = FALSE;
    hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
    tid = start_host_object(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHLFLAGS_NORMAL, &thread);
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
    ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
    if (FAILED(hres))
    {
        end_host_object(tid, thread);
        IStream_Release(stream);
        return;
    }
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    IStream_Release(stream);
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    /* Creating a stub for new iface causes new external connection. */
    hres = ItestDual_QueryInterface(iface, &IID_ITestSecondDisp, (void**)&second);
    ok(hres == S_OK, "Could not get ITestSecondDisp iface: %08x\n", hres);
    todo_wine
    ok(external_connections == 2, "external_connections = %d\n", external_connections);
 
    ITestSecondDisp_Release(second);
    todo_wine
    ok(external_connections == 2, "external_connections = %d\n", external_connections);
 
    expect_last_release_closes = TRUE;
    ItestDual_Release(iface);
    ok(external_connections == 0, "external_connections = %d\n", external_connections);
 
    end_host_object(tid, thread);
 
    /* A test with direct CoMarshalInterface call. */
    hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
 
    expect_last_release_closes = FALSE;
    hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    expect_last_release_closes = TRUE;
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hres = CoReleaseMarshalData(stream);
    ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
    ok(external_connections == 0, "external_connections = %d\n", external_connections);
 
    /* Two separated marshal data are still one external connection. */
    hres = CreateStreamOnHGlobal(NULL, TRUE, &stream2);
    ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
 
    expect_last_release_closes = FALSE;
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    hres = CoMarshalInterface(stream2, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hres = CoReleaseMarshalData(stream);
    ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
    ok(external_connections == 1, "external_connections = %d\n", external_connections);
 
    expect_last_release_closes = TRUE;
    IStream_Seek(stream2, zero, STREAM_SEEK_SET, NULL);
    hres = CoReleaseMarshalData(stream2);
    ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
    ok(external_connections == 0, "external_connections = %d\n", external_connections);
 
    IStream_Release(stream);
    IStream_Release(stream2);
 
    /* Weak table marshaling does not increment external connections */
    hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
 
    hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
    ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
    ok(external_connections == 0, "external_connections = %d\n", external_connections);
 
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
    ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
    ok(external_connections == 0, "external_connections = %d\n", external_connections);
    ItestDual_Release(iface);
 
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hres = CoReleaseMarshalData(stream);
    ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
    ok(external_connections == 0, "external_connections = %d\n", external_connections);
 
    IStream_Release(stream);
}

Referenced by START_TEST().

test_libattr()

static void test_libattr ( void  )

static

Definition at line 3509 of file tmarshal.c.

{
    ITypeLib *pTypeLib;
    HRESULT hr;
    TLIBATTR *pattr;
 
    hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
    ok_ole_success(hr, LoadRegTypeLib);
    if (FAILED(hr))
        return;
 
    hr = ITypeLib_GetLibAttr(pTypeLib, &pattr);
    ok_ole_success(hr, GetLibAttr);
    if (SUCCEEDED(hr))
    {
        ok(pattr->lcid == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), "lcid %x\n", pattr->lcid);
 
        ITypeLib_ReleaseTLibAttr(pTypeLib, pattr);
    }
 
    ITypeLib_Release(pTypeLib);
}

Referenced by START_TEST().

test_marshal_array()

static void test_marshal_array ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2581 of file tmarshal.c.

{
    VARIANT var_in[2], var_out[2], var_in_out[2];
    ISomethingFromDispatch *proxy_sfd;
    array_t in, out, in_out;
    MYSTRUCT struct_in[2];
    HRESULT hr;
    int i = 2;
 
    memcpy(in, test_array1, sizeof(array_t));
    memcpy(out, test_array2, sizeof(array_t));
    memcpy(in_out, test_array3, sizeof(array_t));
    hr = IWidget_array(widget, in, out, in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!memcmp(&in, &test_array1, sizeof(array_t)), "Arrays didn't match.\n");
    ok(!memcmp(&out, &test_array5, sizeof(array_t)), "Arrays didn't match.\n");
    ok(!memcmp(&in_out, &test_array6, sizeof(array_t)), "Arrays didn't match.\n");
 
    V_VT(&var_in[0]) = VT_I4;          V_I4(&var_in[0])       = 1;
    V_VT(&var_in[1]) = VT_BYREF|VT_I4; V_I4REF(&var_in[1])    = &i;
    V_VT(&var_out[0]) = VT_I4;         V_I4(&var_out[0])      = 3;
    V_VT(&var_out[1]) = VT_I4;         V_I4(&var_out[1])      = 4;
    V_VT(&var_in_out[0]) = VT_I4;      V_I4(&var_in_out[0])   = 5;
    V_VT(&var_in_out[1]) = VT_BSTR;    V_BSTR(&var_in_out[1]) = SysAllocString(test_bstr1);
    hr = IWidget_variant_array(widget, var_in, var_out, var_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(V_VT(&var_in[0]) == VT_I4, "Got wrong type %u.\n", V_VT(&var_in[0]));
    ok(V_I4(&var_in[0]) == 1, "Got wrong value %d.\n", V_I4(&var_in[0]));
    ok(V_VT(&var_in[1]) == (VT_BYREF|VT_I4), "Got wrong type %u.\n", V_VT(&var_in[1]));
    ok(V_I4REF(&var_in[1]) == &i, "Got wrong value %p.\n", V_I4REF(&var_in[1]));
    ok(i == 2, "Got wrong value %d.\n", i);
    ok(V_VT(&var_out[0]) == VT_I1, "Got wrong type %u.\n", V_VT(&var_out[0]));
    ok(V_I1(&var_out[0]) == 9, "Got wrong value %u.\n", V_VT(&var_out[0]));
    ok(V_VT(&var_out[1]) == VT_BSTR, "Got wrong type %u.\n", V_VT(&var_out[1]));
    ok(!lstrcmpW(V_BSTR(&var_out[1]), test_bstr2), "Got wrong value %s.\n", wine_dbgstr_w(V_BSTR(&var_out[1])));
    ok(V_VT(&var_in_out[0]) == VT_I1, "Got wrong type %u.\n", V_VT(&var_in_out[0]));
    ok(V_I1(&var_in_out[0]) == 11, "Got wrong value %u.\n", V_VT(&var_in_out[0]));
    ok(V_VT(&var_in_out[1]) == VT_UNKNOWN, "Got wrong type %u.\n", V_VT(&var_in_out[1]));
    hr = IUnknown_QueryInterface(V_UNKNOWN(&var_in_out[1]), &IID_ISomethingFromDispatch, (void **)&proxy_sfd);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ISomethingFromDispatch_anotherfn(proxy_sfd);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    ISomethingFromDispatch_Release(proxy_sfd);
    release_iface(V_UNKNOWN(&var_in_out[1]));
 
    memcpy(&struct_in[0], &test_mystruct1, sizeof(MYSTRUCT));
    memcpy(&struct_in[1], &test_mystruct2, sizeof(MYSTRUCT));
    hr = IWidget_mystruct_array(widget, struct_in);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
}

Referenced by test_typelibmarshal().

test_marshal_basetypes()

static void test_marshal_basetypes ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 1945 of file tmarshal.c.

{
    VARIANTARG arg[11];
    DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
    HRESULT hr;
 
    signed char c;
    short s;
    int i, i2, *pi;
    hyper h;
    unsigned char uc;
    unsigned short us;
    unsigned int ui;
    MIDL_uhyper uh;
    float f;
    double d;
    STATE st;
 
    V_VT(&arg[10]) = VT_I1;     V_I1(&arg[10]) = 5;
    V_VT(&arg[9])  = VT_I2;     V_I2(&arg[9])  = -123;
    V_VT(&arg[8])  = VT_I4;     V_I4(&arg[8])  = -100000;
    V_VT(&arg[7])  = VT_I8;     V_I8(&arg[7])  = (LONGLONG)-100000 * 1000000;
    V_VT(&arg[6])  = VT_UI1;    V_UI1(&arg[6]) = 0;
    V_VT(&arg[5])  = VT_UI2;    V_UI2(&arg[5]) = 456;
    V_VT(&arg[4])  = VT_UI4;    V_UI4(&arg[4]) = 0xdeadbeef;
    V_VT(&arg[3])  = VT_UI8;    V_UI8(&arg[3]) = (ULONGLONG)1234567890 * 9876543210;
    V_VT(&arg[2])  = VT_R4;     V_R4(&arg[2])  = M_PI;
    V_VT(&arg[1])  = VT_R8;     V_R8(&arg[1])  = M_E;
    V_VT(&arg[0])  = VT_I4;     V_I4(&arg[0])  = STATE_WIDGETIFIED;
    hr = IDispatch_Invoke(disp, DISPID_TM_BASETYPES_IN, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    hr = IWidget_basetypes_in(widget, 5, -123, -100000, (LONGLONG)-100000 * 1000000, 0, 456,
            0xdeadbeef, (ULONGLONG)1234567890 * 9876543210, M_PI, M_E, STATE_WIDGETIFIED);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    c = s = i = h = uc = us = ui = uh = f = d = st = 0;
 
    V_VT(&arg[10]) = VT_BYREF|VT_I1;  V_I1REF(&arg[10]) = &c;
    V_VT(&arg[9])  = VT_BYREF|VT_I2;  V_I2REF(&arg[9])  = &s;
    V_VT(&arg[8])  = VT_BYREF|VT_I4;  V_I4REF(&arg[8])  = &i;
    V_VT(&arg[7])  = VT_BYREF|VT_I8;  V_I8REF(&arg[7])  = &h;
    V_VT(&arg[6])  = VT_BYREF|VT_UI1; V_UI1REF(&arg[6]) = &uc;
    V_VT(&arg[5])  = VT_BYREF|VT_UI2; V_UI2REF(&arg[5]) = &us;
    V_VT(&arg[4])  = VT_BYREF|VT_UI4; V_UI4REF(&arg[4]) = &ui;
    V_VT(&arg[3])  = VT_BYREF|VT_UI8; V_UI8REF(&arg[3]) = &uh;
    V_VT(&arg[2])  = VT_BYREF|VT_R4;  V_R4REF(&arg[2])  = &f;
    V_VT(&arg[1])  = VT_BYREF|VT_R8;  V_R8REF(&arg[1])  = &d;
    V_VT(&arg[0])  = VT_BYREF|VT_I4;  V_I4REF(&arg[0])  = (int *)&st;
    hr = IDispatch_Invoke(disp, DISPID_TM_BASETYPES_OUT, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(c == 10, "Got char %d.\n", c);
    ok(s == -321, "Got short %d.\n", s);
    ok(i == -200000, "Got int %d.\n", i);
    ok(h == (LONGLONG)-200000 * 1000000L, "Got hyper %s.\n", wine_dbgstr_longlong(h));
    ok(uc == 254, "Got unsigned char %u.\n", uc);
    ok(us == 256, "Got unsigned short %u.\n", us);
    ok(ui == 0xf00dfade, "Got unsigned int %i.\n", ui);
    ok(uh == ((((ULONGLONG)0xabcdef01) << 32) | (ULONGLONG)0x23456789),
            "Got unsigned hyper %s.\n", wine_dbgstr_longlong(uh));
    ok(f == (float)M_LN2, "Got float %f.\n", f);
    ok(d == M_LN10, "Got double %f.\n", d);
    ok(st == STATE_UNWIDGETIFIED, "Got state %u.\n", st);
 
    c = s = i = h = uc = us = ui = uh = f = d = st = 0;
 
    hr = IWidget_basetypes_out(widget, &c, &s, &i, &h, &uc, &us, &ui, &uh, &f, &d, &st);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(c == 10, "Got char %d.\n", c);
    ok(s == -321, "Got short %d.\n", s);
    ok(i == -200000, "Got int %d.\n", i);
    ok(h == (LONGLONG)-200000 * 1000000L, "Got hyper %s.\n", wine_dbgstr_longlong(h));
    ok(uc == 254, "Got unsigned char %u.\n", uc);
    ok(us == 256, "Got unsigned short %u.\n", us);
    ok(ui == 0xf00dfade, "Got unsigned int %i.\n", ui);
    ok(uh == ((((ULONGLONG)0xabcdef01) << 32) | (ULONGLONG)0x23456789),
            "Got unsigned hyper %s.\n", wine_dbgstr_longlong(uh));
    ok(f == (float)M_LN2, "Got float %f.\n", f);
    ok(d == M_LN10, "Got double %f.\n", d);
    ok(st == STATE_UNWIDGETIFIED, "Got state %u.\n", st);
 
    /* Test marshalling of public typedefs. */
 
    i = 456;
    i2 = 789;
    pi = &i2;
    hr = IWidget_myint(widget, 123, &i, &pi);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    /* Test that different float ABIs are correctly handled. */
 
    hr = IWidget_float_abi(widget, 1.0f, 2.0, 3, 4.0f, 5.0);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
}

Referenced by test_typelibmarshal().

test_marshal_bstr()

static void test_marshal_bstr ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2394 of file tmarshal.c.

{
    VARIANTARG arg[4];
    DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
    BSTR in, out, in_ptr, in_out;
    HRESULT hr;
    UINT len;
 
    testmode = 0;
    in = SysAllocStringLen(test_bstr1, ARRAY_SIZE(test_bstr1));
    out = NULL;
    in_ptr = SysAllocString(test_bstr2);
    in_out = SysAllocString(test_bstr3);
 
    V_VT(&arg[3]) = VT_BSTR;            V_BSTR(&arg[3])    = in;
    V_VT(&arg[2]) = VT_BSTR|VT_BYREF;   V_BSTRREF(&arg[2]) = &out;
    V_VT(&arg[1]) = VT_BSTR|VT_BYREF;   V_BSTRREF(&arg[1]) = &in_ptr;
    V_VT(&arg[0]) = VT_BSTR|VT_BYREF;   V_BSTRREF(&arg[0]) = &in_out;
    hr = IDispatch_Invoke(disp, DISPID_TM_BSTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(in[1] == test_bstr1[1], "[in] parameter should not be changed.\n");
    ok(in_ptr[1] == 'X', "[in] pointer should be changed.\n");
    ok(in_out[1] == 'X', "[in, out] parameter should be changed.\n");
    len = SysStringLen(out);
    ok(len == lstrlenW(test_bstr4), "Got wrong length %d.\n", len);
    ok(!memcmp(out, test_bstr4, len), "Got string %s.\n", wine_dbgstr_wn(out, len));
 
    in[1] = test_bstr1[1];
    in_ptr[1] = test_bstr2[1];
    in_out[1] = test_bstr3[1];
    SysFreeString(out);
    out = (BSTR)0xdeadbeef;
    hr = IWidget_bstr(widget, in, &out, &in_ptr, &in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(in[1] == test_bstr1[1], "[in] parameter should not be changed.\n");
    ok(in_ptr[1] == test_bstr2[1], "[in] pointer should not be changed.\n");
    ok(in_out[1] == 'X', "[in, out] parameter should be changed.\n");
    len = SysStringLen(out);
    ok(len == lstrlenW(test_bstr4), "Got wrong length %d.\n", len);
    ok(!memcmp(out, test_bstr4, len), "Got string %s.\n", wine_dbgstr_wn(out, len));
    SysFreeString(in);
    SysFreeString(out);
    SysFreeString(in_ptr);
    SysFreeString(in_out);
 
    testmode = 1;
    out = in_ptr = in_out = NULL;
    hr = IWidget_bstr(widget, NULL, &out, &in_ptr, &in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
}

Referenced by test_typelibmarshal().

test_marshal_coclass()

static void test_marshal_coclass ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2632 of file tmarshal.c.

{
    VARIANTARG arg[3];
    DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
    struct coclass_obj *class1, *class2, *class3;
    IUnknown *unk_in, *unk_out, *unk_in_out;
    ICoclass1 *in, *out, *in_out;
    HRESULT hr;
 
    class1 = create_coclass_obj();
    class2 = create_coclass_obj();
    class3 = create_coclass_obj();
 
    hr = IWidget_Coclass(widget, (Coclass1 *)&class1->ICoclass1_iface,
            (Coclass2 *)&class2->ICoclass1_iface, (Coclass3 *)&class3->ICoclass1_iface);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    hr = IWidget_Coclass(widget, (Coclass1 *)&class1->ICoclass2_iface,
            (Coclass2 *)&class2->ICoclass2_iface, (Coclass3 *)&class3->ICoclass2_iface);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    release_iface(&class1->ICoclass1_iface);
    release_iface(&class2->ICoclass1_iface);
    release_iface(&class3->ICoclass1_iface);
 
    testmode = 0;
    class1 = create_coclass_obj();
    class2 = create_coclass_obj();
    class3 = create_coclass_obj();
    in = &class1->ICoclass1_iface;
    out = &class2->ICoclass1_iface;
    in_out = &class3->ICoclass1_iface;
    hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in, (Coclass1 **)&out, (Coclass1 **)&in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(in == &class1->ICoclass1_iface, "[in] parameter should not have changed.\n");
    ok(!out, "[out] parameter should have been cleared.\n");
    ok(in_out == &class3->ICoclass1_iface, "[in, out] parameter should not have changed.\n");
    release_iface(&class1->ICoclass1_iface);
    release_iface(&class2->ICoclass1_iface);
    release_iface(&class3->ICoclass1_iface);
 
    testmode = 1;
    class1 = create_coclass_obj();
    class3 = create_coclass_obj();
    in = &class1->ICoclass1_iface;
    in_out = &class3->ICoclass1_iface;
    ICoclass1_AddRef(in_out);
    hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in,
            (Coclass1 **)&out, (Coclass1 **)&in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ICoclass1_test(out);
    ok(hr == 1, "Got hr %#x.\n", hr);
    ok(in_out != &class3->ICoclass1_iface, "[in, out] parameter should have changed.\n");
    hr = ICoclass1_test(in_out);
    ok(hr == 1, "Got hr %#x.\n", hr);
    release_iface(out);
    release_iface(in_out);
    release_iface(&class1->ICoclass1_iface);
    release_iface(&class3->ICoclass1_iface);
 
    testmode = 2;
    in = out = in_out = NULL;
    hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in,
            (Coclass1 **)&out, (Coclass1 **)&in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ICoclass1_test(in_out);
    ok(hr == 1, "Got hr %#x.\n", hr);
    release_iface(in_out);
 
    testmode = 3;
    in = out = NULL;
    class3 = create_coclass_obj();
    in_out = &class3->ICoclass1_iface;
    hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in,
            (Coclass1 **)&out, (Coclass1 **)&in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!in_out, "Got [in, out] %p.\n", in_out);
 
    /* Test with Invoke(). Note that since we pass VT_UNKNOWN, we don't get our
     * interface back, but rather an IUnknown. */
 
    class1 = create_coclass_obj();
    class2 = create_coclass_obj();
    class3 = create_coclass_obj();
 
    V_VT(&arg[2]) = VT_UNKNOWN;  V_UNKNOWN(&arg[2]) = (IUnknown *)&class1->ICoclass1_iface;
    V_VT(&arg[1]) = VT_UNKNOWN;  V_UNKNOWN(&arg[1]) = (IUnknown *)&class2->ICoclass1_iface;
    V_VT(&arg[0]) = VT_UNKNOWN;  V_UNKNOWN(&arg[0]) = (IUnknown *)&class3->ICoclass1_iface;
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    V_VT(&arg[2]) = VT_UNKNOWN;  V_UNKNOWN(&arg[2]) = (IUnknown *)&class1->ICoclass2_iface;
    V_VT(&arg[1]) = VT_UNKNOWN;  V_UNKNOWN(&arg[1]) = (IUnknown *)&class2->ICoclass2_iface;
    V_VT(&arg[0]) = VT_UNKNOWN;  V_UNKNOWN(&arg[0]) = (IUnknown *)&class3->ICoclass2_iface;
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    V_VT(&arg[2]) = VT_DISPATCH; V_DISPATCH(&arg[2]) = (IDispatch *)&class1->ICoclass1_iface;
    V_VT(&arg[1]) = VT_DISPATCH; V_DISPATCH(&arg[1]) = (IDispatch *)&class2->ICoclass1_iface;
    V_VT(&arg[0]) = VT_DISPATCH; V_DISPATCH(&arg[0]) = (IDispatch *)&class3->ICoclass1_iface;
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    release_iface(&class1->ICoclass1_iface);
    release_iface(&class2->ICoclass1_iface);
    release_iface(&class3->ICoclass1_iface);
 
    testmode = 0;
    class1 = create_coclass_obj();
    class3 = create_coclass_obj();
    unk_in = (IUnknown *)&class1->ICoclass1_iface;
    unk_out = NULL;
    unk_in_out = (IUnknown *)&class3->ICoclass1_iface;
    V_VT(&arg[2]) = VT_UNKNOWN|VT_BYREF;    V_UNKNOWNREF(&arg[2]) = &unk_in;
    V_VT(&arg[1]) = VT_UNKNOWN|VT_BYREF;    V_UNKNOWNREF(&arg[1]) = &unk_out;
    V_VT(&arg[0]) = VT_UNKNOWN|VT_BYREF;    V_UNKNOWNREF(&arg[0]) = &unk_in_out;
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(unk_in == (IUnknown *)&class1->ICoclass1_iface, "[in] parameter should not have changed.\n");
    ok(!unk_out, "[out] parameter should have been cleared.\n");
    ok(unk_in_out == (IUnknown *)&class3->ICoclass1_iface, "[in, out] parameter should not have changed.\n");
    release_iface(&class1->ICoclass1_iface);
    release_iface(&class3->ICoclass1_iface);
 
    testmode = 1;
    class1 = create_coclass_obj();
    class3 = create_coclass_obj();
    unk_in = (IUnknown *)&class1->ICoclass1_iface;
    unk_out = NULL;
    unk_in_out = (IUnknown *)&class3->ICoclass1_iface;
    IUnknown_AddRef(unk_in_out);
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
if (hr == S_OK) {
    hr = IUnknown_QueryInterface(unk_out, &IID_ICoclass1, (void **)&out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ICoclass1_test(out);
    ok(hr == 1, "Got hr %#x.\n", hr);
    ICoclass1_Release(out);
 
    ok(unk_in_out != (IUnknown *)&class3->ICoclass1_iface, "[in, out] parameter should have changed.\n");
    hr = IUnknown_QueryInterface(unk_in_out, &IID_ICoclass1, (void **)&in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ICoclass1_test(in_out);
    ok(hr == 1, "Got hr %#x.\n", hr);
    ICoclass1_Release(in_out);
 
    release_iface(unk_out);
    release_iface(unk_in_out);
}
    release_iface(&class1->ICoclass1_iface);
todo_wine
    release_iface(&class3->ICoclass1_iface);
 
    testmode = 2;
    unk_in = unk_out = unk_in_out = NULL;
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    ok(!unk_out, "[out] parameter should not have been set.\n");
if (hr == S_OK) {
    hr = IUnknown_QueryInterface(unk_in_out, &IID_ICoclass1, (void **)&in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ICoclass1_test(in_out);
    ok(hr == 1, "Got hr %#x.\n", hr);
    ICoclass1_Release(in_out);
 
    release_iface(unk_in_out);
}
 
    testmode = 3;
    unk_in = unk_out = NULL;
    class3 = create_coclass_obj();
    unk_in_out = (IUnknown *)&class3->ICoclass1_iface;
    IUnknown_AddRef(unk_in_out);
    hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
todo_wine
    ok(!unk_in_out, "[in, out] parameter should have been cleared.\n");
 
todo_wine
    release_iface(&class3->ICoclass1_iface);
}

Referenced by test_typelibmarshal().

test_marshal_dispinterface()

static void test_marshal_dispinterface ( void  )

static

Definition at line 3649 of file tmarshal.c.

{
    static const LARGE_INTEGER zero;
 
    ISomethingFromDispatch *disp_obj = create_disp_obj();
    ITypeInfo *typeinfo = NULL;
    IDispatch *proxy_disp;
    IStream *stream;
    HANDLE thread;
    HRESULT hr;
    ULONG ref;
    DWORD tid;
 
    CreateStreamOnHGlobal(NULL, TRUE, &stream);
    tid = start_host_object(stream, &DIID_ItestIF4, (IUnknown *)disp_obj, MSHLFLAGS_NORMAL, &thread);
    IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(stream, &DIID_ItestIF4, (void **)&proxy_disp);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    hr = IDispatch_GetTypeInfo(proxy_disp, 0xdeadbeef, 0, &typeinfo);
    ok(hr == 0xbeefdead, "Got hr %#x.\n", hr);
 
    ref = IDispatch_Release(proxy_disp);
    ok(!ref, "Got outstanding refcount %d.\n", ref);
    ref = IStream_Release(stream);
    ok(!ref, "Got outstanding refcount %d.\n", ref);
    end_host_object(tid, thread);
    ref = ISomethingFromDispatch_Release(disp_obj);
    ok(!ref, "Got outstanding refcount %d.\n", ref);
}

Referenced by START_TEST().

test_marshal_iface()

static void test_marshal_iface ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2156 of file tmarshal.c.

{
    VARIANTARG arg[3];
    DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
    ISomethingFromDispatch *sfd1, *sfd2, *sfd3, *proxy_sfd, *sfd_in, *sfd_out, *sfd_in_out;
    IUnknown *proxy_unk, *proxy_unk2, *unk_in, *unk_out, *unk_in_out;
    IDispatch *proxy_disp;
    HRESULT hr;
 
    testmode = 0;
    sfd1 = create_disp_obj();
    sfd2 = create_disp_obj();
    sfd3 = create_disp_obj();
    hr = IWidget_iface_in(widget, (IUnknown *)sfd1,
            (IDispatch *)sfd2, sfd3);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    release_iface(sfd1);
    release_iface(sfd2);
    release_iface(sfd3);
 
    testmode = 1;
    hr = IWidget_iface_in(widget, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    testmode = 0;
    proxy_unk = (IUnknown *)0xdeadbeef;
    proxy_disp = (IDispatch *)0xdeadbeef;
    proxy_sfd = (ISomethingFromDispatch *)0xdeadbeef;
    hr = IWidget_iface_out(widget, &proxy_unk, &proxy_disp, &proxy_sfd);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    check_iface_marshal(proxy_unk, proxy_disp, proxy_sfd);
    release_iface(proxy_unk);
    release_iface(proxy_disp);
    release_iface(proxy_sfd);
 
    testmode = 1;
    hr = IWidget_iface_out(widget, &proxy_unk, &proxy_disp, &proxy_sfd);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!proxy_unk, "Got unexpected proxy %p.\n", proxy_unk);
    ok(!proxy_disp, "Got unexpected proxy %p.\n", proxy_disp);
    ok(!proxy_sfd, "Got unexpected proxy %p.\n", proxy_sfd);
 
    testmode = 0;
    sfd_in = sfd1 = create_disp_obj();
    sfd_out = sfd2 = create_disp_obj();
    sfd_in_out = sfd3 = create_disp_obj();
    hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(sfd_in == sfd1, "[in] parameter should not have changed.\n");
    ok(!sfd_out, "[out] parameter should have been cleared.\n");
    ok(sfd_in_out == sfd3, "[in, out] parameter should not have changed.\n");
    release_iface(sfd1);
    release_iface(sfd2);
    release_iface(sfd3);
 
    testmode = 1;
    sfd_in = sfd1 = create_disp_obj();
    sfd_in_out = sfd3 = create_disp_obj();
    ISomethingFromDispatch_AddRef(sfd_in_out);
    hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ISomethingFromDispatch_anotherfn(sfd_out);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    ok(sfd_in_out != sfd3, "[in, out] parameter should have changed.\n");
    hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    release_iface(sfd_out);
    release_iface(sfd_in_out);
    release_iface(sfd1);
    release_iface(sfd3);
 
    testmode = 2;
    sfd_in = sfd_out = sfd_in_out = NULL;
    hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!sfd_out, "[out] parameter should not have been set.\n");
    hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    release_iface(sfd_in_out);
 
    testmode = 3;
    sfd_in = sfd_out = NULL;
    sfd_in_out = sfd3 = create_disp_obj();
    ISomethingFromDispatch_AddRef(sfd_in_out);
    hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!sfd_in_out, "Got [in, out] %p.\n", sfd_in_out);
    release_iface(sfd3);
 
    /* Test with Invoke(). Note that since we pass VT_UNKNOWN, we don't get our
     * interface back, but rather an IUnknown. */
 
    testmode = 0;
    sfd1 = create_disp_obj();
    sfd2 = create_disp_obj();
    sfd3 = create_disp_obj();
 
    V_VT(&arg[2]) = VT_UNKNOWN;  V_UNKNOWN(&arg[2]) = (IUnknown *)sfd1;
    V_VT(&arg[1]) = VT_UNKNOWN;  V_UNKNOWN(&arg[1]) = (IUnknown *)sfd2;
    V_VT(&arg[0]) = VT_UNKNOWN;  V_UNKNOWN(&arg[0]) = (IUnknown *)sfd3;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_IN, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    V_VT(&arg[2]) = VT_DISPATCH; V_DISPATCH(&arg[2]) = (IDispatch *)sfd1;
    V_VT(&arg[1]) = VT_DISPATCH; V_DISPATCH(&arg[1]) = (IDispatch *)sfd2;
    V_VT(&arg[0]) = VT_DISPATCH; V_DISPATCH(&arg[0]) = (IDispatch *)sfd3;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_IN, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    release_iface(sfd1);
    release_iface(sfd2);
    release_iface(sfd3);
 
    testmode = 1;
    V_VT(&arg[2]) = VT_UNKNOWN;  V_UNKNOWN(&arg[2]) = NULL;
    V_VT(&arg[1]) = VT_UNKNOWN;  V_UNKNOWN(&arg[1]) = NULL;
    V_VT(&arg[0]) = VT_UNKNOWN;  V_UNKNOWN(&arg[0]) = NULL;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_IN, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    testmode = 0;
    proxy_unk = proxy_unk2 = NULL;
    proxy_disp = NULL;
    V_VT(&arg[2]) = VT_UNKNOWN|VT_BYREF;  V_UNKNOWNREF(&arg[2]) = &proxy_unk;
    V_VT(&arg[1]) = VT_DISPATCH|VT_BYREF; V_DISPATCHREF(&arg[1]) = &proxy_disp;
    V_VT(&arg[0]) = VT_UNKNOWN|VT_BYREF;  V_UNKNOWNREF(&arg[0]) = &proxy_unk2;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_OUT, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
if (hr == S_OK) {
    hr = IUnknown_QueryInterface(proxy_unk2, &IID_ISomethingFromDispatch, (void **)&proxy_sfd);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    check_iface_marshal(proxy_unk, proxy_disp, proxy_sfd);
    ISomethingFromDispatch_Release(proxy_sfd);
    release_iface(proxy_unk);
    release_iface(proxy_disp);
    release_iface(proxy_unk2);
}
 
    testmode = 1;
    proxy_unk = proxy_unk2 = NULL;
    proxy_disp = NULL;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_OUT, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!proxy_unk, "Got unexpected proxy %p.\n", proxy_unk);
    ok(!proxy_disp, "Got unexpected proxy %p.\n", proxy_disp);
    ok(!proxy_unk2, "Got unexpected proxy %p.\n", proxy_unk2);
 
    testmode = 0;
    sfd1 = create_disp_obj();
    sfd3 = create_disp_obj();
    unk_in = (IUnknown *)sfd1;
    unk_out = NULL;
    unk_in_out = (IUnknown *)sfd3;
    V_VT(&arg[2]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[2]) = &unk_in;
    V_VT(&arg[1]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[1]) = &unk_out;
    V_VT(&arg[0]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[0]) = &unk_in_out;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(unk_in == (IUnknown *)sfd1, "[in] parameter should not have changed.\n");
    ok(!unk_out, "[out] parameter should have been cleared.\n");
    ok(unk_in_out == (IUnknown *)sfd3, "[in, out] parameter should not have changed.\n");
    release_iface(sfd1);
    release_iface(sfd3);
 
    testmode = 1;
    sfd1 = create_disp_obj();
    sfd3 = create_disp_obj();
    unk_in = (IUnknown *)sfd1;
    unk_out = NULL;
    unk_in_out = (IUnknown *)sfd3;
    IUnknown_AddRef(unk_in_out);
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
if (hr == S_OK) {
    hr = IUnknown_QueryInterface(unk_out, &IID_ISomethingFromDispatch, (void **)&sfd_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ISomethingFromDispatch_anotherfn(sfd_out);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    ISomethingFromDispatch_Release(sfd_out);
 
    ok(unk_in_out != (IUnknown *)sfd3, "[in, out] parameter should have changed.\n");
    hr = IUnknown_QueryInterface(unk_in_out, &IID_ISomethingFromDispatch, (void **)&sfd_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    ISomethingFromDispatch_Release(sfd_in_out);
 
    release_iface(unk_out);
    release_iface(unk_in_out);
}
    release_iface(sfd1);
todo_wine
    release_iface(sfd3);
 
    testmode = 2;
    unk_in = unk_out = unk_in_out = NULL;
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    ok(!unk_out, "[out] parameter should not have been set.\n");
if (hr == S_OK) {
    hr = IUnknown_QueryInterface(unk_in_out, &IID_ISomethingFromDispatch, (void **)&sfd_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
    ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    ISomethingFromDispatch_Release(sfd_in_out);
 
    release_iface(unk_in_out);
}
 
    testmode = 3;
    unk_in = unk_out = NULL;
    sfd3 = create_disp_obj();
    unk_in_out = (IUnknown *)sfd3;
    IUnknown_AddRef(unk_in_out);
    hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
todo_wine {
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!unk_in_out, "[in, out] parameter should have been cleared.\n");
    release_iface(sfd3);
}
}

Referenced by test_typelibmarshal().

test_marshal_pointer()

static void test_marshal_pointer ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2042 of file tmarshal.c.

{
    VARIANTARG arg[3];
    DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
    int in, out, in_out, *in_ptr, *out_ptr, *in_out_ptr;
    HRESULT hr;
 
    testmode = 0;
 
    in = 123;
    out = 456;
    in_out = 789;
    V_VT(&arg[2]) = VT_BYREF|VT_I4; V_I4REF(&arg[2]) = ∈
    V_VT(&arg[1]) = VT_BYREF|VT_I4; V_I4REF(&arg[1]) = &out;
    V_VT(&arg[0]) = VT_BYREF|VT_I4; V_I4REF(&arg[0]) = &in_out;
    hr = IDispatch_Invoke(disp, DISPID_TM_INT_PTR, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(in == 987, "Got [in] %d.\n", in);
    ok(out == 654, "Got [out] %d.\n", out);
    ok(in_out == 321, "Got [in, out] %d.\n", in_out);
 
    testmode = 1;
 
    in = 123;
    out = 456;
    in_out = 789;
    hr = IWidget_int_ptr(widget, &in, &out, &in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(in == 123, "Got [in] %d.\n", in);
    ok(out == 654, "Got [out] %d.\n", out);
    ok(in_out == 321, "Got [in, out] %d.\n", in_out);
 
    out = in_out = -1;
    hr = IWidget_int_ptr(widget, NULL, &out, &in_out);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
    ok(!out, "[out] parameter should have been cleared.\n");
    ok(in_out == -1, "[in, out] parameter should not have been cleared.\n");
 
    in = in_out = -1;
    hr = IWidget_int_ptr(widget, &in, NULL, &in_out);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
    ok(in == -1, "[in] parameter should not have been cleared.\n");
    ok(in_out == -1, "[in, out] parameter should not have been cleared.\n");
 
    in = out = -1;
    hr = IWidget_int_ptr(widget, &in, &out, NULL);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
    ok(in == -1, "[in] parameter should not have been cleared.\n");
    ok(!out, "[out] parameter should have been cleared.\n");
 
    /* We can't test Invoke() with double pointers, as it is not possible to fit
     * more than one level of indirection into a VARIANTARG. */
 
    testmode = 0;
    in_ptr = out_ptr = in_out_ptr = NULL;
    hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
    ok(hr == S_OK, "Got hr %#x\n", hr);
    ok(!in_ptr, "Got [in] %p.\n", in_ptr);
    ok(!out_ptr, "Got [out] %p.\n", out_ptr);
    ok(!in_out_ptr, "Got [in, out] %p.\n", in_out_ptr);
 
    testmode = 1;
    hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
    ok(hr == S_OK, "Got hr %#x\n", hr);
    ok(*out_ptr == 654, "Got [out] %d.\n", *out_ptr);
    ok(*in_out_ptr == 321, "Got [in, out] %d.\n", *in_out_ptr);
    CoTaskMemFree(out_ptr);
    CoTaskMemFree(in_out_ptr);
 
    testmode = 2;
    in = 123;
    out = 456;
    in_out = 789;
    in_ptr = ∈
    out_ptr = &out;
    in_out_ptr = &in_out;
    hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(out_ptr != &out, "[out] ptr should have changed.\n");
    ok(in_out_ptr == &in_out, "[in, out] ptr should not have changed.\n");
    ok(*out_ptr == 654, "Got [out] %d.\n", *out_ptr);
    ok(*in_out_ptr == 321, "Got [in, out] %d.\n", *in_out_ptr);
 
    testmode = 3;
    in_ptr = out_ptr = NULL;
    in_out = 789;
    in_out_ptr = &in_out;
    hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!in_out_ptr, "Got [in, out] %p.\n", in_out_ptr);
 
    out_ptr = &out;
    in_out_ptr = &in_out;
    hr = IWidget_int_ptr_ptr(widget, NULL, &out_ptr, &in_out_ptr);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
    ok(!out_ptr, "[out] parameter should have been cleared.\n");
    ok(in_out_ptr == &in_out, "[in, out] parameter should not have been cleared.\n");
 
    in_ptr = ∈
    in_out_ptr = &in_out;
    hr = IWidget_int_ptr_ptr(widget, &in_ptr, NULL, &in_out_ptr);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
    ok(in_ptr == &in, "[in] parameter should not have been cleared.\n");
    ok(in_out_ptr == &in_out, "[in, out] parameter should not have been cleared.\n");
 
    in_ptr = ∈
    out_ptr = &out;
    hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, NULL);
    ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
    ok(in_ptr == &in, "[in] parameter should not have been cleared.\n");
    ok(!out_ptr, "[out] parameter should have been cleared.\n");
}

Referenced by test_typelibmarshal().

test_marshal_safearray()

static void test_marshal_safearray ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2498 of file tmarshal.c.

{
    SAFEARRAY *in, *out, *out2, *in_ptr, *in_out;
    HRESULT hr;
 
    in = make_safearray(3);
    out = out2 = make_safearray(5);
    in_ptr = make_safearray(7);
    in_out = make_safearray(9);
    hr = IWidget_safearray(widget, in, &out, &in_ptr, &in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    check_safearray(in, 3);
    check_safearray(out, 4);
    check_safearray(out2, 5);
    check_safearray(in_ptr, 7);
    check_safearray(in_out, 6);
 
    SafeArrayDestroy(in);
    SafeArrayDestroy(out);
    SafeArrayDestroy(out2);
    SafeArrayDestroy(in_ptr);
    SafeArrayDestroy(in_out);
}

Referenced by test_typelibmarshal().

test_marshal_struct()

static void test_marshal_struct ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2522 of file tmarshal.c.

{
    MYSTRUCT out, in_ptr, in_out, *in_ptr_ptr;
    RECT rect_out, rect_in_ptr, rect_in_out;
    ISomethingFromDispatch *sfd;
    struct complex complex;
    int i, i2, *pi = &i2;
    HRESULT hr;
 
    memcpy(&out, &test_mystruct2, sizeof(MYSTRUCT));
    memcpy(&in_ptr, &test_mystruct3, sizeof(MYSTRUCT));
    memcpy(&in_out, &test_mystruct4, sizeof(MYSTRUCT));
    hr = IWidget_mystruct(widget, test_mystruct1, &out, &in_ptr, &in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(!memcmp(&out, &test_mystruct5, sizeof(MYSTRUCT)), "Structs didn't match.\n");
    ok(!memcmp(&in_ptr, &test_mystruct3, sizeof(MYSTRUCT)), "Structs didn't match.\n");
    ok(!memcmp(&in_out, &test_mystruct7, sizeof(MYSTRUCT)), "Structs didn't match.\n");
 
    memcpy(&in_ptr, &test_mystruct1, sizeof(MYSTRUCT));
    in_ptr_ptr = &in_ptr;
    hr = IWidget_mystruct_ptr_ptr(widget, &in_ptr_ptr);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    /* Make sure that "thin" structs (<=8 bytes) are handled correctly in x86-64. */
 
    hr = IWidget_thin_struct(widget, test_thin_struct);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    /* Make sure we can handle an imported type. */
 
    rect_out = test_rect2;
    rect_in_ptr = test_rect3;
    rect_in_out = test_rect4;
    hr = IWidget_rect(widget, test_rect1, &rect_out, &rect_in_ptr, &rect_in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(EqualRect(&rect_out, &test_rect5), "Rects didn't match.\n");
    ok(EqualRect(&rect_in_ptr, &test_rect3), "Rects didn't match.\n");
    ok(EqualRect(&rect_in_out, &test_rect7), "Rects didn't match.\n");
 
    /* Test complex structs. */
    complex.c = 98;
    complex.i = 76543;
    i = 2;
    complex.pi = &i;
    i2 = 10;
    complex.ppi = &pi;
    complex.iface = create_disp_obj();
    sfd = create_disp_obj();
    complex.iface_ptr = &sfd;
    complex.bstr = SysAllocString(test_bstr2);
    V_VT(&complex.var) = VT_I4;
    V_I4(&complex.var) = 123;
    memcpy(&complex.mystruct, &test_mystruct1, sizeof(MYSTRUCT));
    memcpy(complex.arr, test_array1, sizeof(array_t));
    complex.myint = 456;
    hr = IWidget_complex_struct(widget, complex);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
}

Referenced by test_typelibmarshal().

test_marshal_variant()

static void test_marshal_variant ( IWidget *  widget, IDispatch *  disp  )

static

Definition at line 2446 of file tmarshal.c.

{
    VARIANTARG arg[4];
    DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
    VARIANT out, in_ptr, in_out;
    HRESULT hr;
    BSTR bstr;
 
    testmode = 0;
    V_VT(&out) = VT_I4;
    V_I4(&out) = 1;
    V_VT(&in_ptr) = VT_I4;
    V_I4(&in_ptr) = -1;
    V_VT(&in_out) = VT_BSTR;
    V_BSTR(&in_out) = bstr = SysAllocString(test_bstr2);
 
    V_VT(&arg[3]) = VT_CY;
    V_CY(&arg[3]).Hi = 0xdababe;
    V_CY(&arg[3]).Lo = 0xdeadbeef;
    V_VT(&arg[2]) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&arg[2]) = &out;
    V_VT(&arg[1]) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&arg[1]) = &in_ptr;
    V_VT(&arg[0]) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&arg[0]) = &in_out;
    hr = IDispatch_Invoke(disp, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL,
            DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(V_VT(&arg[3]) == VT_CY, "Got wrong type %u.\n", V_VT(&arg[3]));
    ok(V_VT(&out) == VT_UI1, "Got wrong type %u.\n", V_VT(&out));
    ok(V_UI1(&out) == 3, "Got wrong value %d.\n", V_UI1(&out));
    VariantClear(&out);
    ok(V_VT(&in_ptr) == VT_I2, "Got wrong type %u.\n", V_VT(&in_ptr));
    ok(V_I2(&in_ptr) == 4, "Got wrong value %d.\n", V_I1(&in_ptr));
    ok(V_VT(&in_out) == VT_I1, "Got wrong type %u.\n", V_VT(&in_out));
    ok(V_I1(&in_out) == 5, "Got wrong value %d.\n", V_I1(&in_out));
 
    testmode = 1;
    V_VT(&out) = VT_I4;
    V_I4(&out) = 1;
    V_VT(&in_ptr) = VT_I4;
    V_I4(&in_ptr) = -1;
    V_VT(&in_out) = VT_BSTR;
    V_BSTR(&in_out) = bstr = SysAllocString(test_bstr2);
    hr = IWidget_variant(widget, arg[3], &out, &in_ptr, &in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
    ok(V_VT(&arg[3]) == VT_CY, "Got wrong type %u.\n", V_VT(&arg[3]));
    ok(V_VT(&out) == VT_UI1, "Got wrong type %u.\n", V_VT(&out));
    ok(V_UI1(&out) == 3, "Got wrong value %d.\n", V_UI1(&out));
    ok(V_VT(&in_ptr) == VT_I4, "Got wrong type %u.\n", V_VT(&in_ptr));
    ok(V_I2(&in_ptr) == -1, "Got wrong value %d.\n", V_I1(&in_ptr));
    ok(V_VT(&in_out) == VT_I1, "Got wrong type %u.\n", V_VT(&in_out));
    ok(V_I1(&in_out) == 5, "Got wrong value %d.\n", V_I1(&in_out));
}

Referenced by test_typelibmarshal().

test_StaticWidget()

static void test_StaticWidget ( void  )

static

Definition at line 3467 of file tmarshal.c.

{
    ITypeInfo *type_info;
    DISPPARAMS dispparams;
    VARIANTARG vararg[4];
    EXCEPINFO excepinfo;
    VARIANT varresult;
    HRESULT hr;
 
    type_info = get_type_info(&IID_IStaticWidget);
 
    /* call TestDual */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    V_VT(vararg) = VT_DISPATCH;
    V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
    VariantInit(&varresult);
    hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
            &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
    VariantClear(&varresult);
 
    /* call TestSecondIface */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    V_VT(vararg) = VT_DISPATCH;
    V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
    VariantInit(&varresult);
    hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTSECONDIFACE, DISPATCH_METHOD,
            &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
    VariantClear(&varresult);
 
    ITypeInfo_Release(type_info);
}

Referenced by START_TEST().

test_typelibmarshal()

static void test_typelibmarshal ( void  )

static

Definition at line 2828 of file tmarshal.c.

{
    static const WCHAR szCat[] = { 'C','a','t',0 };
    static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
    static const WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
    HRESULT hr;
    IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
    IWidget *pWidget;
    IStream *pStream;
    IDispatch *pDispatch;
    static const LARGE_INTEGER ullZero;
    EXCEPINFO excepinfo;
    VARIANT varresult;
    DISPID dispidNamed = DISPID_PROPERTYPUT;
    DISPPARAMS dispparams;
    VARIANTARG vararg[4];
    STATE the_state;
    HANDLE thread;
    DWORD tid;
    BSTR bstr;
    ITypeInfo *pTypeInfo;
    UINT uval;
 
    ok(pKEW != NULL, "Widget creation failed\n");
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
    IKindaEnumWidget_Release(pKEW);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
    if (FAILED(hr))
    {
        end_host_object(tid, thread);
        return;
    }
 
    hr = IKindaEnumWidget_Next(pKEW, &pWidget);
    ok_ole_success(hr, IKindaEnumWidget_Next);
 
    IKindaEnumWidget_Release(pKEW);
 
    /* call GetTypeInfoCount (direct) */
    hr = IWidget_GetTypeInfoCount(pWidget, &uval);
    ok_ole_success(hr, IWidget_GetTypeInfoCount);
    hr = IWidget_GetTypeInfoCount(pWidget, &uval);
    ok_ole_success(hr, IWidget_GetTypeInfoCount);
 
    hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
    ok_ole_success(hr, IWidget_QueryInterface);
 
    /* call put_Name */
    VariantInit(&vararg[0]);
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
        excepinfo.wCode, excepinfo.scode);
    VariantClear(&varresult);
 
    /* call put_Name (direct) */
    bstr = SysAllocString(szSuperman);
    hr = IWidget_put_Name(pWidget, bstr);
    ok_ole_success(hr, IWidget_put_Name);
    SysFreeString(bstr);
 
    /* call get_Name */
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
        excepinfo.wCode, excepinfo.scode);
    trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
    VariantClear(&varresult);
 
    /* call get_Name (direct) */
    bstr = (void *)0xdeadbeef;
    hr = IWidget_get_Name(pWidget, &bstr);
    ok_ole_success(hr, IWidget_get_Name);
    ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
    SysFreeString(bstr);
 
    /* call DoSomething without optional arguments */
    VariantInit(&vararg[0]);
    VariantInit(&vararg[1]);
    V_VT(&vararg[1]) = VT_R8;
    V_R8(&vararg[1]) = 3.141;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 2;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
    VariantClear(&varresult);
 
    /* call DoSomething with optional argument set to VT_EMPTY */
    VariantInit(&vararg[0]);
    VariantInit(&vararg[1]);
    VariantInit(&vararg[2]);
    V_VT(&vararg[2]) = VT_R8;
    V_R8(&vararg[2]) = 3.141;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 3;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
    VariantClear(&varresult);
 
    /* call DoSomething with optional arguments set to VT_ERROR/DISP_E_PARAMNOTFOUND */
    VariantInit(&vararg[0]);
    VariantInit(&vararg[1]);
    VariantInit(&vararg[2]);
    VariantInit(&vararg[3]);
    V_VT(&vararg[3]) = VT_R8;
    V_R8(&vararg[3]) = 3.141;
    V_VT(&vararg[1]) = VT_ERROR;
    V_ERROR(&vararg[1]) = DISP_E_PARAMNOTFOUND;
    V_VT(&vararg[0]) = VT_ERROR;
    V_ERROR(&vararg[0]) = DISP_E_PARAMNOTFOUND;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 4;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
    VariantClear(&varresult);
 
    /* call get_State */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
 
    /* call get_State (direct) */
    hr = IWidget_get_State(pWidget, &the_state);
    ok_ole_success(hr, IWidget_get_state);
    ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
 
    /* call put_State */
    the_state = STATE_WIDGETIFIED;
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BYREF|VT_I4;
    V_I4REF(&vararg[0]) = (int *)&the_state;
    dispparams.cNamedArgs = 1;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
 
    /* call Map */
    bstr = SysAllocString(szTestTest);
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
    V_BSTRREF(&vararg[0]) = &bstr;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
    ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
    VariantClear(&varresult);
    SysFreeString(bstr);
 
    /* call SetOleColor with large negative VT_I4 param */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_I4;
    V_I4(&vararg[0]) = 0x80000005;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
 
    /* call GetOleColor */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    VariantClear(&varresult);
 
    /* call Clone */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
    VariantClear(&varresult);
 
    /* call CloneInterface */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
    VariantClear(&varresult);
 
    /* call CloneDispatch with automatic value getting */
    V_VT(&vararg[0]) = VT_I2;
    V_I2(&vararg[0]) = 1;
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
 
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
        excepinfo.wCode, excepinfo.scode);
 
    ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
    ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
    VariantClear(&varresult);
 
    /* call CloneCoclass */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
 
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
       "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
       excepinfo.wCode, excepinfo.scode);
 
    ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
    ok(V_DISPATCH(&varresult) != NULL, "expected V_DISPATCH(&varresult) != NULL\n");
 
    /* call Value with a VT_VARIANT|VT_BYREF type */
    V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
    V_VARIANTREF(&vararg[0]) = &vararg[1];
    V_VT(&vararg[1]) = VT_I2;
    V_I2(&vararg[1]) = 1;
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
 
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
        excepinfo.wCode, excepinfo.scode);
 
    ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
    ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
    VariantClear(&varresult);
 
    /* call Array with BSTR argument - type mismatch */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BSTR;
    V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_ARRAY, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == DISP_E_TYPEMISMATCH || hr == DISP_E_BADVARTYPE, "expected DISP_E_TYPEMISMATCH, got %#x\n", hr);
    SysFreeString(V_BSTR(&vararg[0]));
 
    /* call ArrayPtr with BSTR argument - type mismatch */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BSTR;
    V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARRAYPTR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == DISP_E_TYPEMISMATCH || hr == DISP_E_BADVARTYPE, "expected DISP_E_TYPEMISMATCH, got %#x\n", hr);
    SysFreeString(V_BSTR(&vararg[0]));
 
    /* call VarArg */
    VariantInit(&vararg[3]);
    V_VT(&vararg[3]) = VT_I4;
    V_I4(&vararg[3]) = 3;
    VariantInit(&vararg[2]);
    V_VT(&vararg[2]) = VT_I4;
    V_I4(&vararg[2]) = 0;
    VariantInit(&vararg[1]);
    V_VT(&vararg[1]) = VT_I4;
    V_I4(&vararg[1]) = 1;
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_I4;
    V_I4(&vararg[0]) = 2;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 4;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
 
    /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
    dispidNamed = 0;
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
    dispidNamed = DISPID_PROPERTYPUT;
 
    /* call VarArg_Run */
    VariantInit(&vararg[1]);
    V_VT(&vararg[1]) = VT_BSTR;
    V_BSTR(&vararg[1]) = SysAllocString(szCat);
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BSTR;
    V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 2;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    SysFreeString(V_BSTR(&vararg[1]));
    SysFreeString(V_BSTR(&vararg[0]));
 
    /* call VarArg_Ref_Run */
    VariantInit(&vararg[1]);
    V_VT(&vararg[1]) = VT_BSTR;
    V_BSTR(&vararg[1]) = SysAllocString(szCat);
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BSTR;
    V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 2;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_REF_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
    ok_ole_success(hr, IDispatch_Invoke);
    SysFreeString(V_BSTR(&vararg[1]));
    SysFreeString(V_BSTR(&vararg[0]));
 
    /* call Error */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
    ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
        excepinfo.wCode, excepinfo.scode);
    VariantClear(&varresult);
 
    /* call BstrRet */
    pTypeInfo = NonOleAutomation_GetTypeInfo();
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
    ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
 
    VariantClear(&varresult);
 
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = NULL;
    hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_ERROR, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok(hr == DISP_E_EXCEPTION, "ITypeInfo_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
    ok(V_VT(&varresult) == VT_EMPTY, "V_VT(&varresult) should be VT_EMPTY instead of %d\n", V_VT(&varresult));
    ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
        excepinfo.wCode, excepinfo.scode);
    VariantClear(&varresult);
 
    ITypeInfo_Release(pTypeInfo);
 
    /* tests call put_Name without named arg */
    VariantInit(&vararg[0]);
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
    VariantClear(&varresult);
 
    /* tests param type that cannot be coerced */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_UNKNOWN;
    V_UNKNOWN(&vararg[0]) = NULL;
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
    VariantClear(&varresult);
 
    /* tests bad param type */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_CLSID;
    V_BYREF(&vararg[0]) = NULL;
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
    VariantClear(&varresult);
 
    /* tests too small param count */
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
    VariantClear(&varresult);
 
    /* tests propget function with large param count */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_BSTR;
    V_BSTR(&vararg[0]) = NULL;
    V_VT(&vararg[1]) = VT_I4;
    V_I4(&vararg[1]) = 1;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 2;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = vararg;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
 
    /* test propput with lcid */
 
    /* the lcid passed to the function is the first lcid in the typelib header.
       Since we don't explicitly set an lcid in the idl, it'll default to US English. */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_I4;
    V_I4(&vararg[0]) = 0xcafe;
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    VariantClear(&varresult);
 
    /* test propget with lcid */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    dispparams.rgdispidNamedArgs = NULL;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
    ok(V_I4(&varresult) == 0x409, "got %x\n", V_I4(&varresult));
    VariantClear(&varresult);
 
    /* test propget of INT value */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    dispparams.rgdispidNamedArgs = NULL;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_INT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
    ok(V_I4(&varresult) == -13, "got %x\n", V_I4(&varresult));
    VariantClear(&varresult);
 
    /* test propget of INT value */
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    dispparams.rgdispidNamedArgs = NULL;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_UINT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    ok(V_VT(&varresult) == VT_UI4, "got %x\n", V_VT(&varresult));
    ok(V_UI4(&varresult) == 42, "got %x\n", V_UI4(&varresult));
    VariantClear(&varresult);
 
    /* test byref marshalling */
    uval = 666;
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_UI4|VT_BYREF;
    V_UI4REF(&vararg[0]) = &uval;
    dispparams.cNamedArgs = 0;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    dispparams.rgdispidNamedArgs = NULL;
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_BYREF_UINT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
    ok(V_VT(&vararg[0]) == (VT_UI4|VT_BYREF), "arg VT not unmarshalled correctly: %x\n", V_VT(&vararg[0]));
    ok(V_UI4REF(&vararg[0]) == &uval, "Byref pointer not preserved: %p/%p\n", &uval, V_UI4REF(&vararg[0]));
    ok(*V_UI4REF(&vararg[0]) == 42, "Expected 42 to be returned instead of %u\n", *V_UI4REF(&vararg[0]));
    VariantClear(&varresult);
    VariantClear(&vararg[0]);
 
    /* test propput with optional argument. */
    VariantInit(&vararg[0]);
    V_VT(&vararg[0]) = VT_I4;
    V_I4(&vararg[0]) = 0xcafe;
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.cArgs = 1;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_OPT_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    VariantClear(&varresult);
 
    /* test propput with required argument. */
    VariantInit(&vararg[0]);
    VariantInit(&vararg[1]);
    V_VT(&vararg[0]) = VT_I4;
    V_I4(&vararg[0]) = 0x1234;
    V_VT(&vararg[1]) = VT_I4;
    V_I4(&vararg[1]) = 0x5678;
    dispparams.cNamedArgs = 1;
    dispparams.rgdispidNamedArgs = &dispidNamed;
    dispparams.cArgs = 2;
    dispparams.rgvarg = vararg;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_REQ_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
    ok_ole_success(hr, ITypeInfo_Invoke);
    VariantClear(&varresult);
 
    /* restricted member */
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok( hr == DISP_E_MEMBERNOTFOUND, "got %08x\n", hr );
    VariantClear(&varresult);
 
    /* restricted member with -ve memid (not restricted) */
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.cArgs = 0;
    dispparams.rgvarg = NULL;
    VariantInit(&varresult);
    hr = IDispatch_Invoke(pDispatch, DISPID_TM_NEG_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
    ok( hr == S_OK, "got %08x\n", hr );
    ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
    ok(V_I4(&varresult) == DISPID_TM_NEG_RESTRICTED, "got %x\n", V_I4(&varresult));
    VariantClear(&varresult);
 
    test_marshal_basetypes(pWidget, pDispatch);
    test_marshal_pointer(pWidget, pDispatch);
    test_marshal_iface(pWidget, pDispatch);
    test_marshal_bstr(pWidget, pDispatch);
    test_marshal_variant(pWidget, pDispatch);
    test_marshal_safearray(pWidget, pDispatch);
    test_marshal_struct(pWidget, pDispatch);
    test_marshal_array(pWidget, pDispatch);
    test_marshal_coclass(pWidget, pDispatch);
 
    IDispatch_Release(pDispatch);
    IWidget_Release(pWidget);
 
    trace("calling end_host_object\n");
    end_host_object(tid, thread);
}

Referenced by START_TEST().

TestDual_AddRef()

static ULONG WINAPI TestDual_AddRef ( ItestDual *  iface )

static

Definition at line 349 of file tmarshal.c.

{
    return 2;
}

TestDual_GetIDsOfNames()

static HRESULT WINAPI TestDual_GetIDsOfNames ( ItestDual *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 371 of file tmarshal.c.

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

TestDual_GetTypeInfo()

static HRESULT WINAPI TestDual_GetTypeInfo ( ItestDual *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 365 of file tmarshal.c.

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

TestDual_GetTypeInfoCount()

static HRESULT WINAPI TestDual_GetTypeInfoCount ( ItestDual *  iface, UINT *  pctinfo  )

static

Definition at line 359 of file tmarshal.c.

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

TestDual_Invoke()

static HRESULT WINAPI TestDual_Invoke ( ItestDual *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 378 of file tmarshal.c.

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

TestDual_QueryInterface()

static HRESULT WINAPI TestDual_QueryInterface ( ItestDual *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 325 of file tmarshal.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch)) {
        *ppvObject = &TestDualDisp;
        return S_OK;
    }else if(IsEqualGUID(riid, &IID_ItestDual)) {
        *ppvObject = &TestDual;
        return S_OK;
    }else if(IsEqualGUID(riid, &IID_ITestSecondIface)) {
        *ppvObject = &TestSecondIface;
        return S_OK;
    }else if(IsEqualGUID(riid, &IID_ITestSecondDisp)) {
        *ppvObject = &TestSecondDisp;
        return S_OK;
    }else if (IsEqualGUID(riid, &IID_IExternalConnection)) {
        trace("QI external connection\n");
        *ppvObject = &ExternalConnection;
        return S_OK;
    }
 
    *ppvObject = NULL;
    return E_NOINTERFACE;
}

TestDual_Release()

static ULONG WINAPI TestDual_Release ( ItestDual *  iface )

static

Definition at line 354 of file tmarshal.c.

{
    return 1;
}

TestSecondDisp_AddRef()

static ULONG WINAPI TestSecondDisp_AddRef ( ITestSecondDisp *  iface )

static

Definition at line 269 of file tmarshal.c.

{
    return 2;
}

TestSecondDisp_GetIDsOfNames()

static HRESULT WINAPI TestSecondDisp_GetIDsOfNames ( ITestSecondDisp *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 291 of file tmarshal.c.

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

TestSecondDisp_GetTypeInfo()

static HRESULT WINAPI TestSecondDisp_GetTypeInfo ( ITestSecondDisp *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 285 of file tmarshal.c.

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

TestSecondDisp_GetTypeInfoCount()

static HRESULT WINAPI TestSecondDisp_GetTypeInfoCount ( ITestSecondDisp *  iface, UINT *  pctinfo  )

static

Definition at line 279 of file tmarshal.c.

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

TestSecondDisp_Invoke()

static HRESULT WINAPI TestSecondDisp_Invoke ( ITestSecondDisp *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 298 of file tmarshal.c.

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

TestSecondDisp_QueryInterface()

static HRESULT WINAPI TestSecondDisp_QueryInterface ( ITestSecondDisp *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 264 of file tmarshal.c.

{
    return ItestDual_QueryInterface(&TestDual, riid, ppv);
}

TestSecondDisp_Release()

static ULONG WINAPI TestSecondDisp_Release ( ITestSecondDisp *  iface )

static

Definition at line 274 of file tmarshal.c.

{
    return 1;
}

TestSecondDisp_test()

static HRESULT WINAPI TestSecondDisp_test ( ITestSecondDisp *  iface )

static

Definition at line 306 of file tmarshal.c.

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

TestSecondIface_AddRef()

static ULONG WINAPI TestSecondIface_AddRef ( ITestSecondIface *  iface )

static

Definition at line 240 of file tmarshal.c.

{
    return 2;
}

TestSecondIface_QueryInterface()

static HRESULT WINAPI TestSecondIface_QueryInterface ( ITestSecondIface *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 235 of file tmarshal.c.

{
    return ItestDual_QueryInterface(&TestDual, riid, ppv);
}

TestSecondIface_Release()

static ULONG WINAPI TestSecondIface_Release ( ITestSecondIface *  iface )

static

Definition at line 245 of file tmarshal.c.

{
    return 1;
}

TestSecondIface_test()

static HRESULT WINAPI TestSecondIface_test ( ITestSecondIface *  iface )

static

Definition at line 250 of file tmarshal.c.

{
    return 1;
}

Widget_AddRef()

static ULONG WINAPI Widget_AddRef ( IWidget *  iface )

static

Definition at line 694 of file tmarshal.c.

{
    Widget *This = impl_from_IWidget(iface);
 
    return InterlockedIncrement(&This->refs);
}

Widget_array()

static HRESULT WINAPI Widget_array ( IWidget *  iface, array_t  in, array_t  out, array_t  in_out  )

static

Definition at line 1466 of file tmarshal.c.

{
    static const array_t empty = {0};
    ok(!memcmp(in, test_array1, sizeof(array_t)), "Arrays didn't match.\n");
    ok(!memcmp(out, empty, sizeof(array_t)), "Arrays didn't match.\n");
    ok(!memcmp(in_out, test_array3, sizeof(array_t)), "Arrays didn't match.\n");
 
    memcpy(in, test_array4, sizeof(array_t));
    memcpy(out, test_array5, sizeof(array_t));
    memcpy(in_out, test_array6, sizeof(array_t));
 
    return S_OK;
}

Widget_basetypes_in()

static HRESULT WINAPI Widget_basetypes_in ( IWidget *  iface, signed char  c, short  s, int  i, hyper  h, unsigned char  uc, unsigned short  us, unsigned int  ui, MIDL_uhyper  uh, float  f, double  d, STATE  st  )

static

Definition at line 1110 of file tmarshal.c.

{
    ok(c == 5, "Got char %d.\n", c);
    ok(s == -123, "Got short %d.\n", s);
    ok(i == -100000, "Got int %d.\n", i);
    ok(h == (LONGLONG)-100000 * 1000000, "Got hyper %s.\n", wine_dbgstr_longlong(h));
    ok(uc == 0, "Got unsigned char %u.\n", uc);
    ok(us == 456, "Got unsigned short %u.\n", us);
    ok(ui == 0xdeadbeef, "Got unsigned int %i.\n", ui);
    ok(uh == (ULONGLONG)1234567890 * 9876543210, "Got unsigned hyper %s.\n", wine_dbgstr_longlong(uh));
    ok(f == (float)M_PI, "Got float %f.\n", f);
    ok(d == M_E, "Got double %f.\n", d);
    ok(st == STATE_WIDGETIFIED, "Got state %u.\n", st);
 
    return S_OK;
}

Widget_basetypes_out()

static HRESULT WINAPI Widget_basetypes_out ( IWidget *  iface, signed char *  c, short *  s, int *  i, hyper *  h, unsigned char *  uc, unsigned short *  us, unsigned int *  ui, MIDL_uhyper *  uh, float *  f, double *  d, STATE *  st  )

static

Definition at line 1129 of file tmarshal.c.

{
    *c = 10;
    *s = -321;
    *i = -200000;
    *h = (LONGLONG)-200000 * 1000000;
    *uc = 254;
    *us = 256;
    *ui = 0xf00dfade;
    *uh = (((ULONGLONG)0xabcdef01) << 32) | (ULONGLONG)0x23456789;
    *f = M_LN2;
    *d = M_LN10;
    *st = STATE_UNWIDGETIFIED;
 
    return S_OK;
}

Widget_bstr()

static HRESULT WINAPI Widget_bstr ( IWidget *  iface, BSTR  in, BSTR *  out, BSTR *  in_ptr, BSTR *  in_out  )

static

Definition at line 1294 of file tmarshal.c.

{
    UINT len;
 
    if (testmode == 0)
    {
        len = SysStringByteLen(in);
        ok(len == sizeof(test_bstr1), "Got wrong length %u.\n", len);
        ok(!memcmp(in, test_bstr1, len), "Got string %s.\n", wine_dbgstr_wn(in, len / sizeof(WCHAR)));
        ok(!*out, "Got unexpected output %p.\n", *out);
        len = SysStringLen(*in_ptr);
        ok(len == lstrlenW(test_bstr2), "Got wrong length %u.\n", len);
        ok(!memcmp(*in_ptr, test_bstr2, len), "Got string %s.\n", wine_dbgstr_w(*in_ptr));
        len = SysStringLen(*in_out);
        ok(len == lstrlenW(test_bstr3), "Got wrong length %u.\n", len);
        ok(!memcmp(*in_out, test_bstr3, len), "Got string %s.\n", wine_dbgstr_w(*in_out));
 
        *out = SysAllocString(test_bstr4);
        in[1] = (*in_ptr)[1] = (*in_out)[1] = 'X';
    }
    else if (testmode == 1)
    {
        ok(!in, "Got string %s.\n", wine_dbgstr_w(in));
        ok(!*out, "Got string %s.\n", wine_dbgstr_w(*out));
        ok(!*in_ptr, "Got string %s.\n", wine_dbgstr_w(*in_ptr));
        ok(!*in_out, "Got string %s.\n", wine_dbgstr_w(*in_out));
    }
    return S_OK;
}

Widget_ByRefUInt()

static HRESULT WINAPI Widget_ByRefUInt ( IWidget *  iface, UINT *  i  )

static

Definition at line 1001 of file tmarshal.c.

{
    *i = 42;
    return S_OK;
}

Widget_Clone()

static HRESULT WINAPI Widget_Clone ( IWidget *  iface, IWidget **  ppVal  )

static

Definition at line 872 of file tmarshal.c.

{
    trace("Clone()\n");
    return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
}

Widget_CloneCoclass()

static HRESULT WINAPI Widget_CloneCoclass ( IWidget *  iface, ApplicationObject2 **  ppVal  )

static

Definition at line 888 of file tmarshal.c.

{
    trace("CloneCoclass()\n");
    return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
}

Widget_CloneDispatch()

static HRESULT WINAPI Widget_CloneDispatch ( IWidget *  iface, IDispatch **  ppVal  )

static

Definition at line 880 of file tmarshal.c.

{
    trace("CloneDispatch()\n");
    return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
}

Widget_CloneInterface()

static HRESULT WINAPI Widget_CloneInterface ( IWidget __RPC_FAR *  iface, ISomethingFromDispatch **  ppVal  )

static

Definition at line 958 of file tmarshal.c.

{
    trace("CloneInterface()\n");
    *ppVal = 0;
    return S_OK;
}

Widget_Coclass()

static HRESULT WINAPI Widget_Coclass ( IWidget *  iface, Coclass1 *  class1, Coclass2 *  class2, Coclass3 *  class3  )

static

Definition at line 1518 of file tmarshal.c.

{
    HRESULT hr;
 
    hr = ICoclass1_test((ICoclass1 *)class1);
    ok(hr == 1, "Got hr %#x.\n", hr);
 
    hr = ICoclass2_test((ICoclass2 *)class2);
    ok(hr == 2, "Got hr %#x.\n", hr);
 
    hr = ICoclass1_test((ICoclass1 *)class3);
    ok(hr == 1, "Got hr %#x.\n", hr);
 
    return S_OK;
}

Widget_Coclass_ptr()

static HRESULT WINAPI Widget_Coclass_ptr ( IWidget *  iface, Coclass1 **  in, Coclass1 **  out, Coclass1 **  in_out  )

static

Definition at line 1534 of file tmarshal.c.

{
    struct coclass_obj *obj;
    HRESULT hr;
 
    ok(!*out, "Got [out] %p.\n", *out);
    if (testmode == 0 || testmode == 1)
    {
        hr = ICoclass1_test((ICoclass1 *)*in);
        ok(hr == 1, "Got hr %#x.\n", hr);
        hr = ICoclass1_test((ICoclass1 *)*in_out);
        ok(hr == 1, "Got hr %#x.\n", hr);
    }
 
    if (testmode == 1)
    {
        obj = create_coclass_obj();
        *out = (Coclass1 *)&obj->ICoclass1_iface;
 
        ICoclass1_Release((ICoclass1 *)*in_out);
        obj = create_coclass_obj();
        *in_out = (Coclass1 *)&obj->ICoclass1_iface;
    }
    else if (testmode == 2)
    {
        ok(!*in_out, "Got [in, out] %p.\n", *in_out);
        obj = create_coclass_obj();
        *in_out = (Coclass1 *)&obj->ICoclass1_iface;
    }
    else if (testmode == 3)
    {
        hr = ICoclass1_test((ICoclass1 *)*in_out);
        ok(hr == 1, "Got hr %#x.\n", hr);
        ICoclass1_Release((ICoclass1 *)*in_out);
        *in_out = NULL;
    }
 
    return S_OK;
}

Widget_complex_struct()

static HRESULT WINAPI Widget_complex_struct ( IWidget *  iface, struct complex  in  )

static

Definition at line 1444 of file tmarshal.c.

{
    HRESULT hr;
 
    ok(in.c == 98, "Got char %d.\n", in.c);
    ok(in.i == 76543, "Got int %d.\n", in.i);
    ok(*in.pi == 2, "Got int pointer %d.\n", *in.pi);
    ok(**in.ppi == 10, "Got int double pointer %d.\n", **in.ppi);
    hr = ISomethingFromDispatch_anotherfn(in.iface);
    ok(hr == 0x01234567, "Got wrong hr %#x.\n", hr);
    hr = ISomethingFromDispatch_anotherfn(*in.iface_ptr);
    ok(hr == 0x01234567, "Got wrong hr %#x.\n", hr);
    ok(!lstrcmpW(in.bstr, test_bstr2), "Got string %s.\n", wine_dbgstr_w(in.bstr));
    ok(V_VT(&in.var) == VT_I4, "Got wrong type %u.\n", V_VT(&in.var));
    ok(V_I4(&in.var) == 123, "Got wrong value %d.\n", V_I4(&in.var));
    ok(!memcmp(&in.mystruct, &test_mystruct1, sizeof(MYSTRUCT)), "Structs didn't match.\n");
    ok(!memcmp(in.arr, test_array1, sizeof(array_t)), "Arrays didn't match.\n");
    ok(in.myint == 456, "Got int %d.\n", in.myint);
 
    return S_OK;
}

Widget_Create()

static IWidget * Widget_Create ( void  )

static

Definition at line 1763 of file tmarshal.c.

{
    Widget *This;
    ITypeInfo *pTypeInfo;
    HRESULT hr = E_FAIL;
 
    pTypeInfo = get_type_info(&IID_IWidget);
    if(!pTypeInfo)
        return NULL;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    This->IWidget_iface.lpVtbl = &Widget_VTable;
    This->refs = 1;
    This->pDispatchUnknown = NULL;
 
    hr = CreateStdDispatch((IUnknown *)&This->IWidget_iface, This, pTypeInfo,
                           &This->pDispatchUnknown);
    ok_ole_success(hr, CreateStdDispatch);
    ITypeInfo_Release(pTypeInfo);
 
    if (SUCCEEDED(hr))
        return &This->IWidget_iface;
    else
    {
        HeapFree(GetProcessHeap(), 0, This);
        return NULL;
    }
}

Referenced by KindaEnum_Next(), and test_DispCallFunc().

Widget_DoSomething()

static HRESULT WINAPI Widget_DoSomething ( IWidget __RPC_FAR *  iface, double  number, BSTR *  str1, BSTR  str2, VARIANT __RPC_FAR *  opt  )

static

Definition at line 809 of file tmarshal.c.

{
    static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
    trace("DoSomething()\n");
 
    ok(number == 3.141, "number(%f) != 3.141\n", number);
    ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
    ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
    ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
    *str1 = SysAllocString(szString);
 
    return S_FALSE;
}

Widget_Error()

static HRESULT WINAPI Widget_Error ( IWidget __RPC_FAR *  iface )

static

Definition at line 951 of file tmarshal.c.

{
    trace("Error()\n");
    return E_NOTIMPL;
}

Widget_float_abi()

static HRESULT WINAPI Widget_float_abi ( IWidget *  iface, float  f, double  d, int  i, float  f2, double  d2  )

static

Definition at line 1148 of file tmarshal.c.

{
    ok(f == 1.0f, "Got float %f.\n", f);
    ok(d == 2.0, "Got double %f.\n", d);
    ok(i == 3, "Got int %d.\n", i);
    ok(f2 == 4.0f, "Got float %f.\n", f2);
    ok(d2 == 5.0, "Got double %f.\n", d2);
 
    return S_OK;
}

Widget_get_Name()

static HRESULT WINAPI Widget_get_Name ( IWidget __RPC_FAR *  iface, BSTR __RPC_FAR *  name  )

static

Definition at line 799 of file tmarshal.c.

{
    static const WCHAR szCat[] = { 'C','a','t',0 };
    trace("get_Name()\n");
    *name = SysAllocString(szCat);
    return S_OK;
}

Widget_get_prop_int()

static HRESULT WINAPI Widget_get_prop_int ( IWidget *  iface, INT *  i  )

static

Definition at line 985 of file tmarshal.c.

{
    trace("get_prop_int(%p)\n", i);
    *i = -13;
    return S_OK;
}

Widget_get_prop_uint()

static HRESULT WINAPI Widget_get_prop_uint ( IWidget *  iface, UINT *  i  )

static

Definition at line 993 of file tmarshal.c.

{
    trace("get_prop_uint(%p)\n", i);
    *i = 42;
    return S_OK;
}

Widget_get_prop_with_lcid()

static HRESULT WINAPI Widget_get_prop_with_lcid ( IWidget *  iface, LONG  lcid, INT *  i  )

static

Definition at line 976 of file tmarshal.c.

{
    trace("get_prop_with_lcid(%08x, %p)\n", lcid, i);
    ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
    *i = lcid;
    return S_OK;
}

Widget_get_State()

static HRESULT WINAPI Widget_get_State ( IWidget __RPC_FAR *  iface, STATE __RPC_FAR *  state  )

static

Definition at line 828 of file tmarshal.c.

{
    trace("get_State() = STATE_WIDGETIFIED\n");
    *state = STATE_WIDGETIFIED;
    return S_OK;
}

Widget_GetIDsOfNames()

static HRESULT WINAPI Widget_GetIDsOfNames ( IWidget __RPC_FAR *  iface, REFIID  riid, LPOLESTR __RPC_FAR *  rgszNames, UINT  cNames, LCID  lcid, DISPID __RPC_FAR *  rgDispId  )

static

Definition at line 750 of file tmarshal.c.

{
    Widget *This = impl_from_IWidget(iface);
    IDispatch *pDispatch;
    HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
    if (SUCCEEDED(hr))
    {
        hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
        IDispatch_Release(pDispatch);
    }
    return hr;
}

Widget_GetOleColor()

static HRESULT WINAPI Widget_GetOleColor ( IWidget *  iface, OLE_COLOR *  pVal  )

static

Definition at line 863 of file tmarshal.c.

{
    trace("GetOleColor() = 0x8000000f\n");
    *pVal = 0x8000000f;
    return S_FALSE;
}

Widget_GetTypeInfo()

static HRESULT WINAPI Widget_GetTypeInfo ( IWidget __RPC_FAR *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo __RPC_FAR *__RPC_FAR *  ppTInfo  )

static

Definition at line 733 of file tmarshal.c.

{
    Widget *This = impl_from_IWidget(iface);
    IDispatch *pDispatch;
    HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
    if (SUCCEEDED(hr))
    {
        hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
        IDispatch_Release(pDispatch);
    }
    return hr;
}

Widget_GetTypeInfoCount()

static HRESULT WINAPI Widget_GetTypeInfoCount ( IWidget *  iface, UINT __RPC_FAR *  pctinfo  )

static

Definition at line 718 of file tmarshal.c.

{
    Widget *This = impl_from_IWidget(iface);
    IDispatch *pDispatch;
    HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
    if (SUCCEEDED(hr))
    {
        hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
        IDispatch_Release(pDispatch);
    }
    return hr;
}

Widget_iface_in()

static HRESULT WINAPI Widget_iface_in ( IWidget *  iface, IUnknown *  unk, IDispatch *  disp, ISomethingFromDispatch *  sfd  )

static

Definition at line 1229 of file tmarshal.c.

{
    if (testmode == 0)
        check_iface_marshal(unk, disp, sfd);
    else if (testmode == 1)
    {
        ok(!unk, "Got iface %p.\n", unk);
        ok(!disp, "Got iface %p.\n", disp);
        ok(!sfd, "Got iface %p.\n", sfd);
    }
    return S_OK;
}

Widget_iface_out()

static HRESULT WINAPI Widget_iface_out ( IWidget *  iface, IUnknown **  unk, IDispatch **  disp, ISomethingFromDispatch **  sfd  )

static

Definition at line 1242 of file tmarshal.c.

{
    ok(!*unk, "Got iface %p.\n", *unk);
    ok(!*disp, "Got iface %p.\n", *disp);
    ok(!*sfd, "Got iface %p.\n", *sfd);
 
    if (testmode == 0)
    {
        *unk = (IUnknown *)create_disp_obj();
        *disp = (IDispatch *)create_disp_obj();
        *sfd = create_disp_obj();
    }
    return S_OK;
}

Widget_iface_ptr()

static HRESULT WINAPI Widget_iface_ptr ( IWidget *  iface, ISomethingFromDispatch **  in, ISomethingFromDispatch **  out, ISomethingFromDispatch **  in_out  )

static

Definition at line 1257 of file tmarshal.c.

{
    HRESULT hr;
 
    ok(!*out, "Got [out] %p.\n", *out);
    if (testmode == 0 || testmode == 1)
    {
        hr = ISomethingFromDispatch_anotherfn(*in);
        ok(hr == 0x01234567, "Got hr %#x.\n", hr);
        hr = ISomethingFromDispatch_anotherfn(*in_out);
        ok(hr == 0x01234567, "Got hr %#x.\n", hr);
    }
 
    if (testmode == 1)
    {
        *out = create_disp_obj();
        ISomethingFromDispatch_Release(*in_out);
        *in_out = create_disp_obj();
    }
    else if (testmode == 2)
    {
        ok(!*in, "Got [in] %p.\n", *in);
        ok(!*in_out, "Got [in, out] %p.\n", *in_out);
        *in_out = create_disp_obj();
    }
    else if (testmode == 3)
    {
        hr = ISomethingFromDispatch_anotherfn(*in_out);
        ok(hr == 0x01234567, "Got hr %#x.\n", hr);
        ISomethingFromDispatch_Release(*in_out);
        *in_out = NULL;
    }
 
    return S_OK;
}

Widget_int_ptr()

static HRESULT WINAPI Widget_int_ptr ( IWidget *  iface, int *  in, int *  out, int *  in_out  )

static

Definition at line 1159 of file tmarshal.c.

{
    ok(*in == 123, "Got [in] %d.\n", *in);
    if (testmode == 0)  /* Invoke() */
        ok(*out == 456, "Got [out] %d.\n", *out);
    else if (testmode == 1)
        ok(!*out, "Got [out] %d.\n", *out);
    ok(*in_out == 789, "Got [in, out] %d.\n", *in_out);
 
    *in = 987;
    *out = 654;
    *in_out = 321;
 
    return S_OK;
}

Widget_int_ptr_ptr()

static HRESULT WINAPI Widget_int_ptr_ptr ( IWidget *  iface, int **  in, int **  out, int **  in_out  )

static

Definition at line 1175 of file tmarshal.c.

{
    ok(!*out, "Got [out] %p.\n", *out);
    if (testmode == 0)
    {
        ok(!*in, "Got [in] %p.\n", *in);
        ok(!*in_out, "Got [in, out] %p.\n", *in_out);
    }
    else if (testmode == 1)
    {
        ok(!*in, "Got [in] %p.\n", *in);
        ok(!*in_out, "Got [in, out] %p.\n", *in_out);
 
        *out = CoTaskMemAlloc(sizeof(int));
        **out = 654;
        *in_out = CoTaskMemAlloc(sizeof(int));
        **in_out = 321;
    }
    else if (testmode == 2)
    {
        ok(**in == 123, "Got [in] %d.\n", **in);
        ok(**in_out == 789, "Got [in, out] %d.\n", **in_out);
 
        *out = CoTaskMemAlloc(sizeof(int));
        **out = 654;
        **in_out = 321;
    }
    else if (testmode == 3)
    {
        ok(**in_out == 789, "Got [in, out] %d.\n", **in_out);
        *in_out = NULL;
    }
 
    return S_OK;
}

Widget_Invoke()

static HRESULT WINAPI Widget_Invoke ( IWidget __RPC_FAR *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS __RPC_FAR *  pDispParams, VARIANT __RPC_FAR *  pVarResult, EXCEPINFO __RPC_FAR *  pExcepInfo, UINT __RPC_FAR *  puArgErr  )

static

Definition at line 769 of file tmarshal.c.

{
    Widget *This = impl_from_IWidget(iface);
    IDispatch *pDispatch;
    HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
    if (SUCCEEDED(hr))
    {
        hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
        IDispatch_Release(pDispatch);
    }
    return hr;
}

Widget_Map()

static HRESULT WINAPI Widget_Map ( IWidget *  iface, BSTR  bstrId, BSTR *  sValue  )

static

Definition at line 845 of file tmarshal.c.

{
    trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
    *sValue = SysAllocString(bstrId);
    return S_OK;
}

Widget_myint()

static HRESULT WINAPI Widget_myint ( IWidget *  iface, myint_t  val, myint_t *  ptr, myint_t **  ptr_ptr  )

static

Definition at line 1510 of file tmarshal.c.

{
    ok(val == 123, "Got value %d.\n", val);
    ok(*ptr == 456, "Got single ptr ref %d.\n", *ptr);
    ok(**ptr_ptr == 789, "Got double ptr ref %d.\n", **ptr_ptr);
    return S_OK;
}

Widget_mystruct()

static HRESULT WINAPI Widget_mystruct ( IWidget *  iface, MYSTRUCT  in, MYSTRUCT *  out, MYSTRUCT *  in_ptr, MYSTRUCT *  in_out  )

static

Definition at line 1404 of file tmarshal.c.

{
    static const MYSTRUCT empty = {0};
    ok(!memcmp(&in, &test_mystruct1, sizeof(in)), "Structs didn't match.\n");
    ok(!memcmp(out, &empty, sizeof(*out)), "Structs didn't match.\n");
    ok(!memcmp(in_ptr, &test_mystruct3, sizeof(*in_ptr)), "Structs didn't match.\n");
    ok(!memcmp(in_out, &test_mystruct4, sizeof(*in_out)), "Structs didn't match.\n");
 
    memcpy(out, &test_mystruct5, sizeof(*out));
    memcpy(in_ptr, &test_mystruct6, sizeof(*in_ptr));
    memcpy(in_out, &test_mystruct7, sizeof(*in_out));
    return S_OK;
}

Widget_mystruct_array()

static HRESULT WINAPI Widget_mystruct_array ( IWidget *  iface, MYSTRUCT  in[2]  )

static

Definition at line 1503 of file tmarshal.c.

{
    ok(!memcmp(&in[0], &test_mystruct1, sizeof(MYSTRUCT)), "Structs didn't match.\n");
    ok(!memcmp(&in[1], &test_mystruct2, sizeof(MYSTRUCT)), "Structs didn't match.\n");
    return S_OK;
}

Widget_mystruct_ptr_ptr()

static HRESULT WINAPI Widget_mystruct_ptr_ptr ( IWidget *  iface, MYSTRUCT **  in  )

static

Definition at line 1418 of file tmarshal.c.

{
    ok(!memcmp(*in, &test_mystruct1, sizeof(**in)), "Structs didn't match.\n");
    return S_OK;
}

Widget_neg_restrict()

static HRESULT WINAPI Widget_neg_restrict ( IWidget *  iface, INT *  i  )

static

Definition at line 1033 of file tmarshal.c.

{
    trace("neg_restrict\n");
    *i = DISPID_TM_NEG_RESTRICTED;
    return S_OK;
}

Widget_pos_restrict()

static HRESULT WINAPI Widget_pos_restrict ( IWidget *  iface, INT *  i  )

static

Definition at line 1026 of file tmarshal.c.

{
    trace("restrict\n");
    *i = DISPID_TM_RESTRICTED;
    return S_OK;
}

Widget_put_Name()

static HRESULT WINAPI Widget_put_Name ( IWidget __RPC_FAR *  iface, BSTR  name  )

static

Definition at line 791 of file tmarshal.c.

{
    trace("put_Name(%s)\n", wine_dbgstr_w(name));
    return S_OK;
}

Widget_put_prop_opt_arg()

static HRESULT WINAPI Widget_put_prop_opt_arg ( IWidget *  iface, INT  opt, INT  i  )

static

Definition at line 1008 of file tmarshal.c.

{
    trace("put_prop_opt_arg(%08x, %08x)\n", opt, i);
    todo_wine ok(opt == 0, "got opt=%08x\n", opt);
    ok(i == 0xcafe, "got i=%08x\n", i);
    return S_OK;
}

Widget_put_prop_req_arg()

static HRESULT WINAPI Widget_put_prop_req_arg ( IWidget *  iface, INT  req, INT  i  )

static

Definition at line 1017 of file tmarshal.c.

{
    trace("put_prop_req_arg(%08x, %08x)\n", req, i);
    ok(req == 0x5678, "got req=%08x\n", req);
    ok(i == 0x1234, "got i=%08x\n", i);
    return S_OK;
}

Widget_put_prop_with_lcid()

static HRESULT WINAPI Widget_put_prop_with_lcid ( IWidget *  iface, LONG  lcid, INT  i  )

static

Definition at line 967 of file tmarshal.c.

{
    trace("put_prop_with_lcid(%08x, %x)\n", lcid, i);
    ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
    ok(i == 0xcafe, "got %08x\n", i);
    return S_OK;
}

Widget_put_State()

static HRESULT WINAPI Widget_put_State ( IWidget __RPC_FAR *  iface, STATE  state  )

static

Definition at line 837 of file tmarshal.c.

{
    trace("put_State(%d)\n", state);
    return S_OK;
}

Widget_QueryInterface()

static HRESULT WINAPI Widget_QueryInterface ( IWidget *  iface, REFIID  riid, void __RPC_FAR *__RPC_FAR *  ppvObject  )

static

Definition at line 676 of file tmarshal.c.

{
    if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
    {
        IWidget_AddRef(iface);
        *ppvObject = iface;
        return S_OK;
    }
    else
    {
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
}

Referenced by Widget_Clone(), Widget_CloneCoclass(), and Widget_CloneDispatch().

Widget_rect()

static HRESULT WINAPI Widget_rect ( IWidget *  iface, RECT  in, RECT *  out, RECT *  in_ptr, RECT *  in_out  )

static

Definition at line 1430 of file tmarshal.c.

{
    static const RECT empty = {0};
    ok(EqualRect(&in, &test_rect1), "Rects didn't match.\n");
    ok(EqualRect(out, &empty), "Rects didn't match.\n");
    ok(EqualRect(in_ptr, &test_rect3), "Rects didn't match.\n");
    ok(EqualRect(in_out, &test_rect4), "Rects didn't match.\n");
 
    *out = test_rect5;
    *in_ptr = test_rect6;
    *in_out = test_rect7;
    return S_OK;
}

Widget_Release()

static ULONG WINAPI Widget_Release ( IWidget *  iface )

static

Definition at line 702 of file tmarshal.c.

{
    Widget *This = impl_from_IWidget(iface);
    ULONG refs = InterlockedDecrement(&This->refs);
    if (!refs)
    {
        IUnknown_Release(This->pDispatchUnknown);
        memset(This, 0xcc, sizeof(*This));
        HeapFree(GetProcessHeap(), 0, This);
        trace("Widget destroyed!\n");
    }
 
    return refs;
}

Widget_safearray()

static HRESULT WINAPI Widget_safearray ( IWidget *  iface, SAFEARRAY *  in, SAFEARRAY **  out, SAFEARRAY **  in_ptr, SAFEARRAY **  in_out  )

static

Definition at line 1386 of file tmarshal.c.

{
    HRESULT hr;
 
    check_safearray(in, 3);
    ok(!*out, "Got array %p.\n", *out);
    check_safearray(*in_ptr, 7);
    check_safearray(*in_out, 9);
 
    hr = SafeArrayDestroy(*in_out);
    ok(hr == S_OK, "Got hr %#x.\n", hr);
 
    *out = make_safearray(4);
    *in_out = make_safearray(6);
 
    return S_OK;
}

Widget_SetOleColor()

static HRESULT WINAPI Widget_SetOleColor ( IWidget *  iface, OLE_COLOR  val  )

static

Definition at line 855 of file tmarshal.c.

{
    trace("SetOleColor(0x%x)\n", val);
    return S_OK;
}

Widget_thin_struct()

static HRESULT WINAPI Widget_thin_struct ( IWidget *  iface, struct thin  in  )

static

Definition at line 1424 of file tmarshal.c.

{
    ok(!memcmp(&in, &test_thin_struct, sizeof(in)), "Structs didn't match.\n");
    return S_OK;
}

Widget_Value()

static HRESULT WINAPI Widget_Value ( IWidget __RPC_FAR *  iface, VARIANT *  value, VARIANT *  retval  )

static

Definition at line 896 of file tmarshal.c.

{
    trace("Value(%p, %p)\n", value, retval);
    ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
    ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
    V_VT(retval) = VT_I2;
    V_I2(retval) = 1234;
    return S_OK;
}

Widget_VarArg()

static HRESULT WINAPI Widget_VarArg ( IWidget *  iface, int  numexpect, SAFEARRAY *  values  )

static

Definition at line 917 of file tmarshal.c.

{
    LONG lbound, ubound, i;
    VARIANT * data;
    HRESULT hr;
 
    trace("VarArg(%p)\n", values);
 
    hr = SafeArrayGetLBound(values, 1, &lbound);
    ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
    ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
 
    hr = SafeArrayGetUBound(values, 1, &ubound);
    ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
    ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
 
    hr = SafeArrayAccessData(values, (LPVOID)&data);
    ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 
    for (i=0; i<=ubound-lbound; i++)
    {
        ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
        ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
    }
 
    hr = SafeArrayUnaccessData(values);
    ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
 
    return S_OK;
}

Widget_VarArg_Ref_Run()

static HRESULT WINAPI Widget_VarArg_Ref_Run ( IWidget *  iface, BSTR  name, SAFEARRAY **  params, VARIANT *  result  )

static

Definition at line 1075 of file tmarshal.c.

{
    static const WCHAR catW[] = { 'C','a','t',0 };
    static const WCHAR supermanW[] = { 'S','u','p','e','r','m','a','n',0 };
    LONG bound;
    VARIANT *var;
    BSTR bstr;
    HRESULT hr;
 
    trace("VarArg_Ref_Run(%p,%p,%p)\n", name, params, result);
 
    ok(!lstrcmpW(name, catW), "got %s\n", wine_dbgstr_w(name));
 
    hr = SafeArrayGetLBound(*params, 1, &bound);
    ok(hr == S_OK, "SafeArrayGetLBound error %#x\n", hr);
    ok(bound == 0, "expected 0, got %d\n", bound);
 
    hr = SafeArrayGetUBound(*params, 1, &bound);
    ok(hr == S_OK, "SafeArrayGetUBound error %#x\n", hr);
    ok(bound == 0, "expected 0, got %d\n", bound);
 
    hr = SafeArrayAccessData(*params, (void **)&var);
    ok(hr == S_OK, "SafeArrayAccessData error %#x\n", hr);
 
    ok(V_VT(&var[0]) == VT_BSTR, "expected VT_BSTR, got %d\n", V_VT(&var[0]));
    bstr = V_BSTR(&var[0]);
    ok(!lstrcmpW(bstr, supermanW), "got %s\n", wine_dbgstr_w(bstr));
 
    hr = SafeArrayUnaccessData(*params);
    ok(hr == S_OK, "SafeArrayUnaccessData error %#x\n", hr);
 
    return S_OK;
}

Widget_VarArg_Run()

static HRESULT WINAPI Widget_VarArg_Run ( IWidget *  iface, BSTR  name, SAFEARRAY *  params, VARIANT *  result  )

static

Definition at line 1040 of file tmarshal.c.

{
    static const WCHAR catW[] = { 'C','a','t',0 };
    static const WCHAR supermanW[] = { 'S','u','p','e','r','m','a','n',0 };
    LONG bound;
    VARIANT *var;
    BSTR bstr;
    HRESULT hr;
 
    trace("VarArg_Run(%p,%p,%p)\n", name, params, result);
 
    ok(!lstrcmpW(name, catW), "got %s\n", wine_dbgstr_w(name));
 
    hr = SafeArrayGetLBound(params, 1, &bound);
    ok(hr == S_OK, "SafeArrayGetLBound error %#x\n", hr);
    ok(bound == 0, "expected 0, got %d\n", bound);
 
    hr = SafeArrayGetUBound(params, 1, &bound);
    ok(hr == S_OK, "SafeArrayGetUBound error %#x\n", hr);
    ok(bound == 0, "expected 0, got %d\n", bound);
 
    hr = SafeArrayAccessData(params, (void **)&var);
    ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 
    ok(V_VT(&var[0]) == VT_BSTR, "expected VT_BSTR, got %d\n", V_VT(&var[0]));
    bstr = V_BSTR(&var[0]);
    ok(!lstrcmpW(bstr, supermanW), "got %s\n", wine_dbgstr_w(bstr));
 
    hr = SafeArrayUnaccessData(params);
    ok(hr == S_OK, "SafeArrayUnaccessData error %#x\n", hr);
 
    return S_OK;
}

Widget_variant()

static HRESULT WINAPI Widget_variant ( IWidget *  iface, VARIANT  in, VARIANT *  out, VARIANT *  in_ptr, VARIANT *  in_out  )

static

Definition at line 1324 of file tmarshal.c.

{
    ok(V_VT(&in) == VT_CY, "Got wrong type %#x.\n", V_VT(&in));
    ok(V_CY(&in).Hi == 0xdababe && V_CY(&in).Lo == 0xdeadbeef,
            "Got wrong value %s.\n", wine_dbgstr_longlong(V_CY(&in).int64));
    if (testmode == 0)
    {
        ok(V_VT(out) == VT_I4, "Got wrong type %u.\n", V_VT(out));
        ok(V_I4(out) == 1, "Got wrong value %d.\n", V_I4(out));
    }
    else
        ok(V_VT(out) == VT_EMPTY, "Got wrong type %u.\n", V_VT(out));
    ok(V_VT(in_ptr) == VT_I4, "Got wrong type %u.\n", V_VT(in_ptr));
    ok(V_I4(in_ptr) == -1, "Got wrong value %d.\n", V_I4(in_ptr));
    ok(V_VT(in_out) == VT_BSTR, "Got wrong type %u.\n", V_VT(in_out));
    ok(!lstrcmpW(V_BSTR(in_out), test_bstr2), "Got wrong value %s.\n",
            wine_dbgstr_w(V_BSTR(in_out)));
 
    V_VT(&in) = VT_I4;
    V_I4(&in) = 2;
    V_VT(out) = VT_UI1;
    V_UI1(out) = 3;
    V_VT(in_ptr) = VT_I2;
    V_I2(in_ptr) = 4;
    VariantClear(in_out);
    V_VT(in_out) = VT_I1;
    V_I1(in_out) = 5;
    return S_OK;
}

Widget_variant_array()

static HRESULT WINAPI Widget_variant_array ( IWidget *  iface, VARIANT  in[2], VARIANT  out[2], VARIANT  in_out[2]  )

static

Definition at line 1480 of file tmarshal.c.

{
    ok(V_VT(&in[0]) == VT_I4, "Got wrong type %u.\n", V_VT(&in[0]));
    ok(V_I4(&in[0]) == 1, "Got wrong value %d.\n", V_I4(&in[0]));
    ok(V_VT(&in[1]) == (VT_BYREF|VT_I4), "Got wrong type %u.\n", V_VT(&in[1]));
    ok(*V_I4REF(&in[1]) == 2, "Got wrong value %d.\n", *V_I4REF(&in[1]));
    ok(V_VT(&out[0]) == VT_EMPTY, "Got wrong type %u.\n", V_VT(&out[0]));
    ok(V_VT(&out[1]) == VT_EMPTY, "Got wrong type %u.\n", V_VT(&out[1]));
    ok(V_VT(&in_out[0]) == VT_I4, "Got wrong type %u.\n", V_VT(&in_out[0]));
    ok(V_I4(&in_out[0]) == 5, "Got wrong type %u.\n", V_VT(&in_out[0]));
    ok(V_VT(&in_out[1]) == VT_BSTR, "Got wrong type %u.\n", V_VT(&in_out[1]));
    ok(!lstrcmpW(V_BSTR(&in_out[1]), test_bstr1), "Got wrong value %s.\n", wine_dbgstr_w(V_BSTR(&in[1])));
 
    V_VT(&in[0]) = VT_I1;          V_I1(&in[0])          = 7;
    V_VT(&in[1]) = VT_I1;          V_I1(&in[1])          = 8;
    V_VT(&out[0]) = VT_I1;         V_I1(&out[0])         = 9;
    V_VT(&out[1]) = VT_BSTR;       V_BSTR(&out[1])       = SysAllocString(test_bstr2);
    V_VT(&in_out[0]) = VT_I1;      V_I1(&in_out[0])      = 11;
    V_VT(&in_out[1]) = VT_UNKNOWN; V_UNKNOWN(&in_out[1]) = (IUnknown *)create_disp_obj();
 
    return S_OK;
}

Widget_VariantArrayPtr()

static HRESULT WINAPI Widget_VariantArrayPtr ( IWidget *  iface, SAFEARRAY **  values  )

static

Definition at line 909 of file tmarshal.c.

{
    trace("VariantArrayPtr(%p)\n", values);
    return S_OK;
}

Variable Documentation

coclass1_vtbl

const ICoclass1Vtbl coclass1_vtbl

static

Initial value:

=
{
    coclass1_QueryInterface,
    coclass1_AddRef,
    coclass1_Release,
    coclass1_GetTypeInfoCount,
    coclass1_GetTypeInfo,
    coclass1_GetIDsOfNames,
    coclass1_Invoke,
    coclass1_test,
}

Definition at line 629 of file tmarshal.c.

Referenced by create_coclass_obj().

coclass2_vtbl

const ICoclass2Vtbl coclass2_vtbl

static

Initial value:

=
{
    coclass2_QueryInterface,
    coclass2_AddRef,
    coclass2_Release,
    coclass2_GetTypeInfoCount,
    coclass2_GetTypeInfo,
    coclass2_GetIDsOfNames,
    coclass2_Invoke,
    coclass2_test,
}

Definition at line 641 of file tmarshal.c.

Referenced by create_coclass_obj().

disp_obj_vtbl

const ISomethingFromDispatchVtbl disp_obj_vtbl

static

Initial value:

=
{
    disp_obj_QueryInterface,
    disp_obj_AddRef,
    disp_obj_Release,
    disp_obj_GetTypeInfoCount,
    disp_obj_GetTypeInfo,
    disp_obj_GetIDsOfNames,
    disp_obj_Invoke,
    disp_obj_anotherfn,
}

Definition at line 472 of file tmarshal.c.

Referenced by create_disp_obj().

expect_last_release_closes

BOOL expect_last_release_closes

static

Definition at line 182 of file tmarshal.c.

Referenced by ExternalConnection_ReleaseConnection(), and test_external_connection().

external_connections

int external_connections

static

Definition at line 181 of file tmarshal.c.

Referenced by ExternalConnection_AddConnection(), ExternalConnection_ReleaseConnection(), and test_external_connection().

ExternalConnection

IExternalConnection ExternalConnection = { &ExternalConnectionVtbl }

static

Definition at line 231 of file tmarshal.c.

Referenced by TestDual_QueryInterface().

ExternalConnectionVtbl

const IExternalConnectionVtbl ExternalConnectionVtbl

static

Initial value:

= {
    ExternalConnection_QueryInterface,
    ExternalConnection_AddRef,
    ExternalConnection_Release,
    ExternalConnection_AddConnection,
    ExternalConnection_ReleaseConnection
}

Definition at line 223 of file tmarshal.c.

KindaEnumWidget_VTable

const IKindaEnumWidgetVtbl KindaEnumWidget_VTable

static

Initial value:

=
{
    KindaEnum_QueryInterface,
    KindaEnum_AddRef,
    KindaEnum_Release,
    KindaEnum_Next,
    KindaEnum_Count,
    KindaEnum_Reset,
    KindaEnum_Clone
}

Definition at line 1864 of file tmarshal.c.

Referenced by KindaEnumWidget_Create().

LPVARIANT

LPVARIANT

Definition at line 33 of file tmarshal.c.

NonOleAutomation

INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable }

static

Definition at line 1927 of file tmarshal.c.

Referenced by test_typelibmarshal().

NonOleAutomation_VTable

INonOleAutomationVtbl NonOleAutomation_VTable

static

Initial value:

=
{
    NonOleAutomation_QueryInterface,
    NonOleAutomation_AddRef,
    NonOleAutomation_Release,
    NonOleAutomation_BstrRet,
    NonOleAutomation_Error
}

Definition at line 1918 of file tmarshal.c.

StaticWidget

IStaticWidget StaticWidget = { &StaticWidgetVtbl }

static

Definition at line 1711 of file tmarshal.c.

Referenced by test_StaticWidget().

StaticWidgetVtbl

const IStaticWidgetVtbl StaticWidgetVtbl

static

Initial value:

= {
    StaticWidget_QueryInterface,
    StaticWidget_AddRef,
    StaticWidget_Release,
    StaticWidget_GetTypeInfoCount,
    StaticWidget_GetTypeInfo,
    StaticWidget_GetIDsOfNames,
    StaticWidget_Invoke,
    StaticWidget_TestDual,
    StaticWidget_TestSecondIface
}

Definition at line 1699 of file tmarshal.c.

test_array1

const array_t test_array1 = {1,2,3,4}

static

Definition at line 71 of file tmarshal.c.

Referenced by test_marshal_array(), test_marshal_struct(), Widget_array(), and Widget_complex_struct().

test_array2

const array_t test_array2 = {5,6,7,8}

static

Definition at line 72 of file tmarshal.c.

Referenced by test_marshal_array().

test_array3

const array_t test_array3 = {9,10,11,12}

static

Definition at line 73 of file tmarshal.c.

Referenced by test_marshal_array(), and Widget_array().

test_array4

const array_t test_array4 = {13,14,15,16}

static

Definition at line 74 of file tmarshal.c.

Referenced by Widget_array().

test_array5

const array_t test_array5 = {17,18,19,20}

static

Definition at line 75 of file tmarshal.c.

Referenced by test_marshal_array(), and Widget_array().

test_array6

const array_t test_array6 = {21,22,23,24}

static

Definition at line 76 of file tmarshal.c.

Referenced by test_marshal_array(), and Widget_array().

test_bstr1

const WCHAR test_bstr1[] = {'f','o','o',0,'b','a','r'}

static

Definition at line 48 of file tmarshal.c.

Referenced by test_marshal_array(), test_marshal_bstr(), Widget_bstr(), and Widget_variant_array().

test_bstr2

const WCHAR test_bstr2[] = {'t','e','s','t',0}

static

Definition at line 49 of file tmarshal.c.

Referenced by test_marshal_array(), test_marshal_bstr(), test_marshal_struct(), test_marshal_variant(), Widget_bstr(), Widget_complex_struct(), Widget_variant(), and Widget_variant_array().

test_bstr3

const WCHAR test_bstr3[] = {'q','u','x',0}

static

Definition at line 50 of file tmarshal.c.

Referenced by test_marshal_bstr(), and Widget_bstr().

test_bstr4

const WCHAR test_bstr4[] = {'a','b','c',0}

static

Definition at line 51 of file tmarshal.c.

Referenced by test_marshal_bstr(), and Widget_bstr().

test_mystruct1

const MYSTRUCT test_mystruct1 = {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432), {0,1,2,3,4,5,6,7}}

static

Definition at line 53 of file tmarshal.c.

Referenced by test_marshal_array(), test_marshal_struct(), Widget_complex_struct(), Widget_mystruct(), Widget_mystruct_array(), and Widget_mystruct_ptr_ptr().

test_mystruct2

const MYSTRUCT test_mystruct2 = {0x91827364, ULL_CONST(0x88776655, 0x44332211), {3,6,1,4,0,1,3,0}}

static

Definition at line 54 of file tmarshal.c.

Referenced by test_marshal_array(), test_marshal_struct(), and Widget_mystruct_array().

test_mystruct3

const MYSTRUCT test_mystruct3 = {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415), {9,2,4,5,6,5,1,3}}

static

Definition at line 55 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_mystruct().

test_mystruct4

const MYSTRUCT test_mystruct4 = {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425), {0,4,6,7,3,6,7,4}}

static

Definition at line 56 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_mystruct().

test_mystruct5

const MYSTRUCT test_mystruct5 = {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435), {1,6,7,3,8,4,6,5}}

static

Definition at line 57 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_mystruct().

test_mystruct6

const MYSTRUCT test_mystruct6 = {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445), {3,6,5,3,4,8,0,9}}

static

Definition at line 58 of file tmarshal.c.

Referenced by Widget_mystruct().

test_mystruct7

const MYSTRUCT test_mystruct7 = {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455), {1,8,4,4,4,2,3,1}}

static

Definition at line 59 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_mystruct().

test_rect1

const RECT test_rect1 = {1,2,3,4}

static

Definition at line 63 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_rect().

test_rect2

const RECT test_rect2 = {5,6,7,8}

static

Definition at line 64 of file tmarshal.c.

Referenced by test_gethrgn(), and test_marshal_struct().

test_rect3

const RECT test_rect3 = {9,10,11,12}

static

Definition at line 65 of file tmarshal.c.

Referenced by test_gethrgn(), test_marshal_struct(), and Widget_rect().

test_rect4

const RECT test_rect4 = {13,14,15,16}

static

Definition at line 66 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_rect().

test_rect5

const RECT test_rect5 = {17,18,19,20}

static

Definition at line 67 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_rect().

test_rect6

const RECT test_rect6 = {21,22,23,24}

static

Definition at line 68 of file tmarshal.c.

Referenced by Widget_rect().

test_rect7

const RECT test_rect7 = {25,26,27,28}

static

Definition at line 69 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_rect().

test_thin_struct

const struct thin test_thin_struct = {-456, 78}

static

Definition at line 61 of file tmarshal.c.

Referenced by test_marshal_struct(), and Widget_thin_struct().

TestDual

static ItestDual TestDual = { &TestDualVtbl }

static

Definition at line 233 of file tmarshal.c.

Referenced by StaticWidget_TestDual(), test_external_connection(), TestDual_QueryInterface(), TestSecondDisp_QueryInterface(), and TestSecondIface_QueryInterface().

TestDualDisp

static ItestDual TestDualDisp = { &TestDualVtbl }

static

Definition at line 233 of file tmarshal.c.

Referenced by test_StaticWidget(), and TestDual_QueryInterface().

TestDualVtbl

ItestDualVtbl TestDualVtbl

static

Initial value:

= {
    TestDual_QueryInterface,
    TestDual_AddRef,
    TestDual_Release,
    TestDual_GetTypeInfoCount,
    TestDual_GetTypeInfo,
    TestDual_GetIDsOfNames,
    TestDual_Invoke
}

Definition at line 386 of file tmarshal.c.

testmode

int testmode

static

Definition at line 662 of file tmarshal.c.

Referenced by test_marshal_bstr(), test_marshal_coclass(), test_marshal_iface(), test_marshal_pointer(), test_marshal_variant(), Widget_bstr(), Widget_Coclass_ptr(), Widget_iface_in(), Widget_iface_out(), Widget_iface_ptr(), Widget_int_ptr(), Widget_int_ptr_ptr(), and Widget_variant().

TestSecondDisp

ITestSecondDisp TestSecondDisp = { &TestSecondDispVtbl }

static

Definition at line 323 of file tmarshal.c.

Referenced by TestDual_QueryInterface().

TestSecondDispVtbl

ITestSecondDispVtbl TestSecondDispVtbl

static

Initial value:

= {
    TestSecondDisp_QueryInterface,
    TestSecondDisp_AddRef,
    TestSecondDisp_Release,
    TestSecondDisp_GetTypeInfoCount,
    TestSecondDisp_GetTypeInfo,
    TestSecondDisp_GetIDsOfNames,
    TestSecondDisp_Invoke,
    TestSecondDisp_test
}

Definition at line 312 of file tmarshal.c.

TestSecondIface

ITestSecondIface TestSecondIface = { &TestSecondIfaceVtbl }

static

Definition at line 262 of file tmarshal.c.

Referenced by StaticWidget_TestSecondIface(), and TestDual_QueryInterface().

TestSecondIfaceVtbl

const ITestSecondIfaceVtbl TestSecondIfaceVtbl

static

Initial value:

= {
    TestSecondIface_QueryInterface,
    TestSecondIface_AddRef,
    TestSecondIface_Release,
    TestSecondIface_test
}

Definition at line 255 of file tmarshal.c.

Widget_VTable

const struct IWidgetVtbl Widget_VTable

static

Definition at line 1574 of file tmarshal.c.

Referenced by Widget_Create().