ReactOS 0.4.16-dev-88-ga65b6ae
Classes | Macros | Typedefs | Functions | Variables
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.

1213{
1214 ISomethingFromDispatch *sfd2;
1215 ITypeInfo *typeinfo;
1216 HRESULT hr;
1217
1218 hr = IUnknown_QueryInterface(unk, &IID_ISomethingFromDispatch, (void **)&sfd2);
1219 ok(hr == S_OK, "Got hr %#x.\n", hr);
1220 ISomethingFromDispatch_Release(sfd2);
1221
1222 hr = IDispatch_GetTypeInfo(disp, 0xdeadbeef, 0, &typeinfo);
1223 ok(hr == 0xbeefdead, "Got hr %#x.\n", hr);
1224
1225 hr = ISomethingFromDispatch_anotherfn(sfd);
1226 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
1227}
ok
#define ok(value,...)
Definition: atltest.h:57
S_OK
#define S_OK
Definition: intsafe.h:52
hr
HRESULT hr
Definition: shlfolder.c:183

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.

1368{
1369 LONG len, i, *data;
1370 HRESULT hr;
1371
1372 hr = SafeArrayGetUBound(sa, 1, &len);
1373 len++;
1374 ok(hr == S_OK, "Got hr %#x.\n", hr);
1375 ok(len == expect, "Expected len %d, got %d.\n", expect, len);
1376
1377 hr = SafeArrayAccessData(sa, (void **)&data);
1378 ok(hr == S_OK, "Got hr %#x.\n", hr);
1379
1380 for (i = 0; i < len; ++i)
1381 ok(data[i] == len + i, "Expected data %d at %d, got %d.\n", len + i, i, data[i]);
1382
1383 SafeArrayUnaccessData(sa);
1384}
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
sa
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
SafeArrayGetUBound
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
Definition: safearray.c:1033
SafeArrayAccessData
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
SafeArrayUnaccessData
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
len
GLenum GLsizei len
Definition: glext.h:6722
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG
long LONG
Definition: pedump.c:60

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.

533{
534 struct coclass_obj *obj = impl_from_ICoclass1(iface);
535 return ++obj->ref;
536}
coclass_obj
Definition: tmarshal.c:493
impl_from_ICoclass1
static struct coclass_obj * impl_from_ICoclass1(ICoclass1 *iface)
Definition: tmarshal.c:499

◆ 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.

562{
563 ok(0, "unexpected call\n");
564 return E_NOTIMPL;
565}
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ coclass1_GetTypeInfo()

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

Definition at line 553 of file tmarshal.c.

555{
556 ok(index == 0xdeadbeef, "Got unexpected index %#x.\n", index);
557 return 0xbeefdead;
558}
index
GLuint index
Definition: glext.h:6031

◆ coclass1_GetTypeInfoCount()

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

Definition at line 547 of file tmarshal.c.

548{
549 ok(0, "unexpected call\n");
550 return E_NOTIMPL;
551}

◆ 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.

569{
570 ok(0, "unexpected call\n");
571 return E_NOTIMPL;
572}

◆ coclass1_QueryInterface()

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

Definition at line 509 of file tmarshal.c.

510{
511 struct coclass_obj *obj = impl_from_ICoclass1(iface);
512
513 if (IsEqualGUID(iid, &IID_IUnknown)
514 || IsEqualGUID(iid, &IID_IDispatch)
515 || IsEqualGUID(iid, &IID_ICoclass1))
516 {
517 *out = iface;
518 ICoclass1_AddRef(iface);
519 return S_OK;
520 }
521 else if (IsEqualGUID(iid, &IID_ICoclass2))
522 {
523 *out = &obj->ICoclass2_iface;
524 ICoclass2_AddRef(*out);
525 return S_OK;
526 }
527
528 *out = NULL;
529 return E_NOINTERFACE;
530}
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
NULL
#define NULL
Definition: types.h:112
IID_IDispatch
const GUID IID_IDispatch
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
out
static FILE * out
Definition: regtests2xml.c:44
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ coclass1_Release()

static ULONG WINAPI coclass1_Release ( ICoclass1 *  iface)
static

Definition at line 538 of file tmarshal.c.

539{
540 struct coclass_obj *obj = impl_from_ICoclass1(iface);
541 LONG ref = --obj->ref;
542 if (!ref)
543 CoTaskMemFree(obj);
544 return ref;
545}
CoTaskMemFree
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
coclass_obj::ref
LONG ref
Definition: tmarshal.c:496
ref
Definition: send.c:48

◆ coclass1_test()

static HRESULT WINAPI coclass1_test ( ICoclass1 *  iface)
static

Definition at line 574 of file tmarshal.c.

575{
576 return 1;
577}

◆ coclass2_AddRef()

static ULONG WINAPI coclass2_AddRef ( ICoclass2 *  iface)
static

Definition at line 585 of file tmarshal.c.

586{
587 struct coclass_obj *obj = impl_from_ICoclass2(iface);
588 return ICoclass1_AddRef(&obj->ICoclass1_iface);
589}
impl_from_ICoclass2
static struct coclass_obj * impl_from_ICoclass2(ICoclass2 *iface)
Definition: tmarshal.c:504

◆ 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.

612{
613 ok(0, "unexpected call\n");
614 return E_NOTIMPL;
615}

◆ coclass2_GetTypeInfo()

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

Definition at line 603 of file tmarshal.c.

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

◆ coclass2_GetTypeInfoCount()

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

Definition at line 597 of file tmarshal.c.

598{
599 ok(0, "unexpected call\n");
600 return E_NOTIMPL;
601}

◆ 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.

619{
620 ok(0, "unexpected call\n");
621 return E_NOTIMPL;
622}

◆ coclass2_QueryInterface()

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

Definition at line 579 of file tmarshal.c.

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

◆ coclass2_Release()

static ULONG WINAPI coclass2_Release ( ICoclass2 *  iface)
static

Definition at line 591 of file tmarshal.c.

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

◆ coclass2_test()

static HRESULT WINAPI coclass2_test ( ICoclass2 *  iface)
static

Definition at line 624 of file tmarshal.c.

625{
626 return 2;
627}

◆ create_coclass_obj()

static struct coclass_obj * create_coclass_obj ( void  )
static

Definition at line 653 of file tmarshal.c.

654{
655 struct coclass_obj *obj = CoTaskMemAlloc(sizeof(*obj));
656 obj->ICoclass1_iface.lpVtbl = &coclass1_vtbl;
657 obj->ICoclass2_iface.lpVtbl = &coclass2_vtbl;
658 obj->ref = 1;
659 return obj;
660};
CoTaskMemAlloc
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
coclass2_vtbl
static const ICoclass2Vtbl coclass2_vtbl
Definition: tmarshal.c:641
coclass1_vtbl
static const ICoclass1Vtbl coclass1_vtbl
Definition: tmarshal.c:629

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.

485{
486 struct disp_obj *obj = CoTaskMemAlloc(sizeof(*obj));
487 obj->ISomethingFromDispatch_iface.lpVtbl = &disp_obj_vtbl;
488 obj->ref = 1;
489 return &obj->ISomethingFromDispatch_iface;
490}
disp_obj
Definition: tmarshal.c:400
disp_obj_vtbl
static const ISomethingFromDispatchVtbl disp_obj_vtbl
Definition: tmarshal.c:472

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.

426{
427 struct disp_obj *obj = impl_from_ISomethingFromDispatch(iface);
428 return ++obj->ref;
429}
impl_from_ISomethingFromDispatch
static struct disp_obj * impl_from_ISomethingFromDispatch(ISomethingFromDispatch *iface)
Definition: tmarshal.c:405

◆ disp_obj_anotherfn()

static HRESULT WINAPI disp_obj_anotherfn ( ISomethingFromDispatch *  iface)
static

Definition at line 467 of file tmarshal.c.

468{
469 return 0x01234567;
470}

◆ 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.

455{
456 ok(0, "unexpected call\n");
457 return E_NOTIMPL;
458}

◆ 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.

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

◆ disp_obj_GetTypeInfoCount()

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

Definition at line 440 of file tmarshal.c.

441{
442 ok(0, "unexpected call\n");
443 return E_NOTIMPL;
444}

◆ 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.

462{
463 ok(0, "unexpected call\n");
464 return E_NOTIMPL;
465}

◆ disp_obj_QueryInterface()

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

Definition at line 410 of file tmarshal.c.

411{
412 if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IDispatch)
413 || IsEqualGUID(iid, &IID_ISomethingFromDispatch)
414 || IsEqualGUID(iid, &DIID_ItestIF4))
415 {
416 *out = iface;
417 ISomethingFromDispatch_AddRef(iface);
418 return S_OK;
419 }
420
421 *out = NULL;
422 return E_NOINTERFACE;
423}

◆ disp_obj_Release()

static ULONG WINAPI disp_obj_Release ( ISomethingFromDispatch *  iface)
static

Definition at line 431 of file tmarshal.c.

432{
433 struct disp_obj *obj = impl_from_ISomethingFromDispatch(iface);
434 LONG ref = --obj->ref;
435 if (!ref)
436 CoTaskMemFree(obj);
437 return ref;
438}
disp_obj::ref
LONG ref
Definition: tmarshal.c:402

◆ end_host_object()

static void end_host_object ( DWORD  tid,
HANDLE  thread 
)
static

Definition at line 172 of file tmarshal.c.

173{
174 BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
175 ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
176 /* be careful of races - don't return until hosting thread has terminated */
177 WaitForSingleObject(thread, INFINITE);
178 CloseHandle(thread);
179}
thread
static HANDLE thread
Definition: service.c:33
CloseHandle
#define CloseHandle
Definition: compat.h:739
INFINITE
#define INFINITE
Definition: serial.h:102
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
tid
static TfClientId tid
Definition: inputprocessor.c:40
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
ret
int ret
Definition: wcstombs-tests.c:31
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
WM_QUIT
#define WM_QUIT
Definition: winuser.h:1626
PostThreadMessageA
BOOL WINAPI PostThreadMessageA(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

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.

202{
203 trace("add connection\n");
204
205 ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
206 ok(!reserved, "reserved = %x\n", reserved);
207 return ++external_connections;
208}
trace
#define trace
Definition: atltest.h:70
reserved
r reserved
Definition: btrfs.c:3006
external_connections
static int external_connections
Definition: tmarshal.c:181

◆ ExternalConnection_AddRef()

static ULONG WINAPI ExternalConnection_AddRef ( IExternalConnection *  iface)
static

Definition at line 191 of file tmarshal.c.

192{
193 return 2;
194}

◆ ExternalConnection_QueryInterface()

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

Definition at line 184 of file tmarshal.c.

185{
186 ok(0, "unexpected call\n");
187 *ppv = NULL;
188 return E_NOINTERFACE;
189}
ppv
REFIID LPVOID * ppv
Definition: atlbase.h:39

◆ ExternalConnection_Release()

static ULONG WINAPI ExternalConnection_Release ( IExternalConnection *  iface)
static

Definition at line 196 of file tmarshal.c.

197{
198 return 1;
199}

◆ ExternalConnection_ReleaseConnection()

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

Definition at line 210 of file tmarshal.c.

212{
213 trace("release connection\n");
214
215 ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
216 ok(!reserved, "reserved = %x\n", reserved);
217
218 ok(fLastReleaseCloses == expect_last_release_closes, "fLastReleaseCloses = %x, expected %x\n",
219 fLastReleaseCloses, expect_last_release_closes);
220 return --external_connections;
221}
expect_last_release_closes
static BOOL expect_last_release_closes
Definition: tmarshal.c:182

◆ get_type_info()

static ITypeInfo * get_type_info ( REFIID  riid)
static

Definition at line 1743 of file tmarshal.c.

1744{
1745 ITypeInfo *pTypeInfo;
1746 ITypeLib *pTypeLib;
1747 HRESULT hr;
1748
1749 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1750 ok_ole_success(hr, LoadRegTypeLib);
1751 if (FAILED(hr))
1752 return NULL;
1753
1754 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
1755 ITypeLib_Release(pTypeLib);
1756 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1757 if (FAILED(hr))
1758 return NULL;
1759
1760 return pTypeInfo;
1761}
LoadRegTypeLib
HRESULT WINAPI LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib **ppTLib)
Definition: typelib.c:531
riid
REFIID riid
Definition: atlbase.h:39
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
LOCALE_NEUTRAL
#define LOCALE_NEUTRAL
ok_ole_success
#define ok_ole_success(hr, func)
Definition: tmarshal.c:36

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.

91{
92 struct host_object_data *data = p;
93 HRESULT hr;
94 MSG msg;
95
96 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
97
98 if (data->filter)
99 {
100 IMessageFilter * prev_filter = NULL;
101 hr = CoRegisterMessageFilter(data->filter, &prev_filter);
102 if (prev_filter) IMessageFilter_Release(prev_filter);
103 ok_ole_success(hr, CoRegisterMessageFilter);
104 }
105
106 hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
107 ok_ole_success(hr, CoMarshalInterface);
108
109 /* force the message queue to be created before signaling parent thread */
110 PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
111
112 SetEvent(data->marshal_event);
113
114 while (GetMessageA(&msg, NULL, 0, 0))
115 {
116 if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
117 {
118 trace("releasing marshal data\n");
119 CoReleaseMarshalData(data->stream);
120 SetEvent((HANDLE)msg.lParam);
121 }
122 else
123 DispatchMessageA(&msg);
124 }
125
126 HeapFree(GetProcessHeap(), 0, data);
127
128 CoUninitialize();
129
130 return hr;
131}
msg
#define msg(x)
Definition: auth_time.c:54
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
CoRegisterMessageFilter
HRESULT WINAPI CoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER *lplpMessageFilter)
Definition: compobj.c:4046
CoInitializeEx
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
CoUninitialize
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
CoReleaseMarshalData
HRESULT WINAPI CoReleaseMarshalData(IStream *pStream)
Definition: marshal.c:2055
CoMarshalInterface
HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
Definition: marshal.c:1876
p
GLfloat GLfloat p
Definition: glext.h:8902
COINIT_APARTMENTTHREADED
@ COINIT_APARTMENTTHREADED
Definition: objbase.h:278
host_object_data
Definition: marshal.c:603
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
RELEASEMARSHALDATA
#define RELEASEMARSHALDATA
Definition: tmarshal.c:78
MSG
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
DispatchMessageA
LRESULT WINAPI DispatchMessageA(_In_ const MSG *)
PeekMessageA
BOOL WINAPI PeekMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
WM_USER
#define WM_USER
Definition: winuser.h:1898
GetMessageA
BOOL WINAPI GetMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
PM_NOREMOVE
#define PM_NOREMOVE
Definition: winuser.h:1198

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.

500{
501 return CONTAINING_RECORD(iface, struct coclass_obj, ICoclass1_iface);
502}
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

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.

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

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.

1720{
1721 return CONTAINING_RECORD(iface, KindaEnum, IKindaEnumWidget_iface);
1722}

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.

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

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.

672{
673 return CONTAINING_RECORD(iface, Widget, IWidget_iface);
674}

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.

1812{
1813 KindaEnum *This = impl_from_IKindaEnumWidget(iface);
1814
1815 return InterlockedIncrement(&This->refs);
1816}
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
impl_from_IKindaEnumWidget
static KindaEnum * impl_from_IKindaEnumWidget(IKindaEnumWidget *iface)
Definition: tmarshal.c:1719

◆ KindaEnum_Clone()

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

Definition at line 1857 of file tmarshal.c.

1860{
1861 return E_NOTIMPL;
1862}

◆ KindaEnum_Count()

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

Definition at line 1844 of file tmarshal.c.

1847{
1848 return E_NOTIMPL;
1849}

◆ KindaEnum_Next()

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

Definition at line 1833 of file tmarshal.c.

1836{
1837 *widget = Widget_Create();
1838 if (*widget)
1839 return S_OK;
1840 else
1841 return E_OUTOFMEMORY;
1842}
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
Widget_Create
static IWidget * Widget_Create(void)
Definition: tmarshal.c:1763

◆ 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.

1796{
1797 if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
1798 {
1799 IKindaEnumWidget_AddRef(iface);
1800 *ppvObject = iface;
1801 return S_OK;
1802 }
1803 else
1804 {
1805 *ppvObject = NULL;
1806 return E_NOINTERFACE;
1807 }
1808}
IsEqualIID
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
ppvObject
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082

◆ KindaEnum_Release()

static ULONG WINAPI KindaEnum_Release ( IKindaEnumWidget *  iface)
static

Definition at line 1818 of file tmarshal.c.

1820{
1821 KindaEnum *This = impl_from_IKindaEnumWidget(iface);
1822 ULONG refs = InterlockedDecrement(&This->refs);
1823 if (!refs)
1824 {
1825 memset(This, 0xcc, sizeof(*This));
1826 HeapFree(GetProcessHeap(), 0, This);
1827 trace("KindaEnumWidget destroyed!\n");
1828 }
1829
1830 return refs;
1831}
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52
memset
#define memset(x, y, z)
Definition: compat.h:39
ULONG
uint32_t ULONG
Definition: typedefs.h:59

◆ KindaEnum_Reset()

static HRESULT WINAPI KindaEnum_Reset ( IKindaEnumWidget *  iface)
static

Definition at line 1851 of file tmarshal.c.

1853{
1854 return E_NOTIMPL;
1855}

◆ KindaEnumWidget_Create()

static IKindaEnumWidget * KindaEnumWidget_Create ( void  )
static

Definition at line 1875 of file tmarshal.c.

1876{
1877 KindaEnum *This;
1878
1879 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1880 if (!This) return NULL;
1881 This->IKindaEnumWidget_iface.lpVtbl = &KindaEnumWidget_VTable;
1882 This->refs = 1;
1883 return &This->IKindaEnumWidget_iface;
1884}
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
KindaEnumWidget_VTable
static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable
Definition: tmarshal.c:1864

Referenced by test_typelibmarshal().

◆ make_safearray()

static SAFEARRAY * make_safearray ( ULONG  len)
static

Definition at line 1354 of file tmarshal.c.

1355{
1356 SAFEARRAY *sa = SafeArrayCreateVector(VT_I4, 0, len);
1357 int i, *data;
1358
1359 SafeArrayAccessData(sa, (void **)&data);
1360 for (i = 0; i < len; ++i)
1361 data[i] = len + i;
1362 SafeArrayUnaccessData(sa);
1363
1364 return sa;
1365}
VT_I4
@ VT_I4
Definition: compat.h:2298
SafeArrayCreateVector
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
Definition: safearray.c:677

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.

1898{
1899 return 2;
1900}

◆ NonOleAutomation_BstrRet()

static BSTR WINAPI NonOleAutomation_BstrRet ( INonOleAutomation *  iface)
static

Definition at line 1907 of file tmarshal.c.

1908{
1909 static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
1910 return SysAllocString(wszTestString);
1911}
SysAllocString
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ NonOleAutomation_Error()

static HRESULT WINAPI NonOleAutomation_Error ( INonOleAutomation *  iface)
static

Definition at line 1913 of file tmarshal.c.

1914{
1915 return E_NOTIMPL;
1916}

◆ NonOleAutomation_GetTypeInfo()

static ITypeInfo * NonOleAutomation_GetTypeInfo ( void  )
static

Definition at line 1929 of file tmarshal.c.

1930{
1931 ITypeLib *pTypeLib;
1932 HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1933 ok_ole_success(hr, LoadRegTypeLib);
1934 if (SUCCEEDED(hr))
1935 {
1936 ITypeInfo *pTypeInfo;
1937 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
1938 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1939 ITypeLib_Release(pTypeLib);
1940 return pTypeInfo;
1941 }
1942 return NULL;
1943}
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50

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.

1887{
1888 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
1889 {
1890 *(INonOleAutomation **)ppv = iface;
1891 return S_OK;
1892 }
1893 *ppv = NULL;
1894 return E_NOINTERFACE;
1895}

◆ NonOleAutomation_Release()

static ULONG WINAPI NonOleAutomation_Release ( INonOleAutomation *  iface)
static

Definition at line 1902 of file tmarshal.c.

1903{
1904 return 1;
1905}

◆ register_current_module_typelib()

static HRESULT register_current_module_typelib ( void  )
static

Definition at line 1724 of file tmarshal.c.

1725{
1726 WCHAR path[MAX_PATH];
1727 CHAR pathA[MAX_PATH];
1728 HRESULT hr;
1729 ITypeLib *typelib;
1730
1731 GetModuleFileNameA(NULL, pathA, MAX_PATH);
1732 MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
1733
1734 hr = LoadTypeLib(path, &typelib);
1735 if (SUCCEEDED(hr))
1736 {
1737 hr = RegisterTypeLib(typelib, path, NULL);
1738 ITypeLib_Release(typelib);
1739 }
1740 return hr;
1741}
CP_ACP
#define CP_ACP
Definition: compat.h:109
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
GetModuleFileNameA
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
Definition: loader.c:539
RegisterTypeLib
HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const WCHAR *szHelpDir)
Definition: typelib.c:656
LoadTypeLib
HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib **pptLib)
Definition: typelib.c:458
pathA
GLuint pathA
Definition: glext.h:11719
CHAR
char CHAR
Definition: xmlstorage.h:175

Referenced by START_TEST().

◆ release_iface_()

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

Definition at line 37 of file tmarshal.c.

38{
39 ULONG ref = IUnknown_Release((IUnknown *)iface);
40 ok_(__FILE__, line)(!ref, "Got outstanding refcount %d.\n", ref);
41 if (ref == 1) IUnknown_Release((IUnknown *)iface);
42}
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
line
Definition: parser.c:49

◆ 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.

156{
157 return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
158}
stream
Definition: parse.h:23
start_host_object2
static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
Definition: tmarshal.c:133

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.

134{
135 DWORD tid = 0;
136 HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
137 struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
138
139 data->stream = stream;
140 data->iid = *riid;
141 data->object = object;
142 data->marshal_flags = marshal_flags;
143 data->marshal_event = marshal_event;
144 data->filter = filter;
145
146 *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
147
148 /* wait for marshaling to complete before returning */
149 WaitForSingleObject(marshal_event, INFINITE);
150 CloseHandle(marshal_event);
151
152 return tid;
153}
FALSE
#define FALSE
Definition: types.h:117
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
filter
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
host_object_data::marshal_event
HANDLE marshal_event
Definition: marshal.c:611
host_object_data::marshal_flags
MSHLFLAGS marshal_flags
Definition: marshal.c:607
host_object_data::object
IUnknown * object
Definition: marshal.c:606
host_object_data::stream
IStream * stream
Definition: marshal.c:604
CreateEventA
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCSTR lpName OPTIONAL)
Definition: synch.c:637
host_object_proc
static DWORD CALLBACK host_object_proc(LPVOID p)
Definition: tmarshal.c:90

Referenced by start_host_object().

◆ START_TEST()

START_TEST ( tmarshal  )

Definition at line 3680 of file tmarshal.c.

3681{
3682 HRESULT hr;
3683 HANDLE hOleaut32 = GetModuleHandleA("oleaut32.dll");
3684 pVarAdd = (void*)GetProcAddress(hOleaut32, "VarAdd");
3685
3686 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
3687
3688 hr = register_current_module_typelib();
3689 if (FAILED(hr))
3690 {
3691 CoUninitialize();
3692 win_skip("Registration of the test typelib failed, skipping tests\n");
3693 return;
3694 }
3695
3696 test_typelibmarshal();
3697 test_DispCallFunc();
3698 test_StaticWidget();
3699 test_libattr();
3700 test_external_connection();
3701 test_marshal_dispinterface();
3702
3703 hr = UnRegisterTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL,
3704 sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
3705 ok_ole_success(hr, UnRegisterTypeLib);
3706
3707 CoUninitialize();
3708}
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
UnRegisterTypeLib
HRESULT WINAPI UnRegisterTypeLib(REFGUID libid, WORD wVerMajor, WORD wVerMinor, LCID lcid, SYSKIND syskind)
Definition: typelib.c:882
hOleaut32
static HMODULE hOleaut32
Definition: olefont.c:50
win_skip
#define win_skip
Definition: test.h:163
test_StaticWidget
static void test_StaticWidget(void)
Definition: tmarshal.c:3467
test_marshal_dispinterface
static void test_marshal_dispinterface(void)
Definition: tmarshal.c:3649
register_current_module_typelib
static HRESULT register_current_module_typelib(void)
Definition: tmarshal.c:1724
test_DispCallFunc
static void test_DispCallFunc(void)
Definition: tmarshal.c:3437
test_libattr
static void test_libattr(void)
Definition: tmarshal.c:3509
test_external_connection
static void test_external_connection(void)
Definition: tmarshal.c:3532
test_typelibmarshal
static void test_typelibmarshal(void)
Definition: tmarshal.c:2828
SYS_WIN32
@ SYS_WIN32
Definition: widltypes.h:552
SYS_WIN64
@ SYS_WIN64
Definition: widltypes.h:554

◆ StaticWidget_AddRef()

static ULONG WINAPI StaticWidget_AddRef ( IStaticWidget *  iface)
static

Definition at line 1647 of file tmarshal.c.

1648{
1649 return 2;
1650}

◆ 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.

1672{
1673 ok(0, "unexpected call\n");
1674 return E_NOTIMPL;
1675}

◆ StaticWidget_GetTypeInfo()

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

Definition at line 1663 of file tmarshal.c.

1665{
1666 ok(0, "unexpected call\n");
1667 return E_NOTIMPL;
1668}

◆ StaticWidget_GetTypeInfoCount()

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

Definition at line 1657 of file tmarshal.c.

1658{
1659 ok(0, "unexpected call\n");
1660 return E_NOTIMPL;
1661}

◆ 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.

1680{
1681 ok(0, "unexpected call\n");
1682 return E_NOTIMPL;
1683}

◆ StaticWidget_QueryInterface()

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

Definition at line 1634 of file tmarshal.c.

1635{
1636 if (IsEqualIID(riid, &IID_IStaticWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
1637 {
1638 IStaticWidget_AddRef(iface);
1639 *ppvObject = iface;
1640 return S_OK;
1641 }
1642
1643 *ppvObject = NULL;
1644 return E_NOINTERFACE;
1645}

◆ StaticWidget_Release()

static ULONG WINAPI StaticWidget_Release ( IStaticWidget *  iface)
static

Definition at line 1652 of file tmarshal.c.

1653{
1654 return 1;
1655}

◆ StaticWidget_TestDual()

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

Definition at line 1685 of file tmarshal.c.

1686{
1687 trace("TestDual()\n");
1688 ok(p == &TestDual, "wrong ItestDual\n");
1689 return S_OK;
1690}
TestDual
static ItestDual TestDual
Definition: tmarshal.c:233

◆ StaticWidget_TestSecondIface()

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

Definition at line 1692 of file tmarshal.c.

1693{
1694 trace("TestSecondIface()\n");
1695 ok(p == &TestSecondIface, "wrong ItestSecondIface\n");
1696 return S_OK;
1697}
TestSecondIface
static ITestSecondIface TestSecondIface
Definition: tmarshal.c:262

◆ test_DispCallFunc()

static void test_DispCallFunc ( void  )
static

Definition at line 3437 of file tmarshal.c.

3438{
3439 static const WCHAR szEmpty[] = { 0 };
3440 VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
3441 VARIANTARG vararg[4];
3442 VARIANTARG varref;
3443 VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
3444 VARIANTARG varresult;
3445 HRESULT hr;
3446 IWidget *pWidget = Widget_Create();
3447 V_VT(&vararg[0]) = VT_R8;
3448 V_R8(&vararg[0]) = 3.141;
3449 V_VT(&vararg[1]) = VT_BSTR;
3450 V_BSTRREF(&vararg[1]) = CoTaskMemAlloc(sizeof(BSTR));
3451 V_VT(&vararg[2]) = VT_BSTR;
3452 V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
3453 V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
3454 V_VARIANTREF(&vararg[3]) = &varref;
3455 V_VT(&varref) = VT_ERROR;
3456 V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
3457 VariantInit(&varresult);
3458 hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
3459 ok_ole_success(hr, DispCallFunc);
3460 VariantClear(&varresult);
3461 SysFreeString(*V_BSTRREF(&vararg[1]));
3462 CoTaskMemFree(V_BSTRREF(&vararg[1]));
3463 VariantClear(&vararg[2]);
3464 IWidget_Release(pWidget);
3465}
szEmpty
static const WCHAR szEmpty[]
Definition: provider.c:50
BSTR
OLECHAR * BSTR
Definition: compat.h:2293
VARTYPE
unsigned short VARTYPE
Definition: compat.h:2254
VT_BSTR
@ VT_BSTR
Definition: compat.h:2303
VT_BYREF
@ VT_BYREF
Definition: compat.h:2342
VT_ERROR
@ VT_ERROR
Definition: compat.h:2305
VT_R8
@ VT_R8
Definition: compat.h:2300
VT_VARIANT
@ VT_VARIANT
Definition: compat.h:2307
VT_UI4
@ VT_UI4
Definition: compat.h:2313
DispCallFunc
HRESULT WINAPI DispCallFunc(void *pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals, VARTYPE *prgvt, VARIANTARG **prgpvarg, VARIANT *pvargResult)
Definition: typelib.c:7071
SysFreeString
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
V_ERROR
#define V_ERROR(A)
Definition: oleauto.h:241
V_BSTRREF
#define V_BSTRREF(A)
Definition: oleauto.h:227
V_VARIANTREF
#define V_VARIANTREF(A)
Definition: oleauto.h:283
V_VT
#define V_VT(A)
Definition: oleauto.h:211
V_BSTR
#define V_BSTR(A)
Definition: oleauto.h:226
V_R8
#define V_R8(A)
Definition: oleauto.h:262
CC_STDCALL
@ CC_STDCALL
Definition: spec2def.c:93
VariantClear
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
VariantInit
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
DISP_E_PARAMNOTFOUND
#define DISP_E_PARAMNOTFOUND
Definition: winerror.h:2513

Referenced by START_TEST().

◆ test_external_connection()

static void test_external_connection ( void  )
static

Definition at line 3532 of file tmarshal.c.

3533{
3534 IStream *stream, *stream2;
3535 ITestSecondDisp *second;
3536 ItestDual *iface;
3537 HANDLE thread;
3538 DWORD tid;
3539 HRESULT hres;
3540
3541 static const LARGE_INTEGER zero;
3542
3543 trace("Testing IExternalConnection...\n");
3544
3545 external_connections = 0;
3546
3547 /* Marshaling an interface increases external connection count. */
3548 expect_last_release_closes = FALSE;
3549 hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
3550 ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
3551 tid = start_host_object(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHLFLAGS_NORMAL, &thread);
3552 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3553
3554 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3555 hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
3556 ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
3557 if (FAILED(hres))
3558 {
3559 end_host_object(tid, thread);
3560 IStream_Release(stream);
3561 return;
3562 }
3563 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3564
3565 IStream_Release(stream);
3566 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3567
3568 /* Creating a stub for new iface causes new external connection. */
3569 hres = ItestDual_QueryInterface(iface, &IID_ITestSecondDisp, (void**)&second);
3570 ok(hres == S_OK, "Could not get ITestSecondDisp iface: %08x\n", hres);
3571 todo_wine
3572 ok(external_connections == 2, "external_connections = %d\n", external_connections);
3573
3574 ITestSecondDisp_Release(second);
3575 todo_wine
3576 ok(external_connections == 2, "external_connections = %d\n", external_connections);
3577
3578 expect_last_release_closes = TRUE;
3579 ItestDual_Release(iface);
3580 ok(external_connections == 0, "external_connections = %d\n", external_connections);
3581
3582 end_host_object(tid, thread);
3583
3584 /* A test with direct CoMarshalInterface call. */
3585 hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
3586 ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
3587
3588 expect_last_release_closes = FALSE;
3589 hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
3590 ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
3591 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3592
3593 expect_last_release_closes = TRUE;
3594 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3595 hres = CoReleaseMarshalData(stream);
3596 ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
3597 ok(external_connections == 0, "external_connections = %d\n", external_connections);
3598
3599 /* Two separated marshal data are still one external connection. */
3600 hres = CreateStreamOnHGlobal(NULL, TRUE, &stream2);
3601 ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
3602
3603 expect_last_release_closes = FALSE;
3604 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3605 hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
3606 ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
3607 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3608
3609 hres = CoMarshalInterface(stream2, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
3610 ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
3611 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3612
3613 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3614 hres = CoReleaseMarshalData(stream);
3615 ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
3616 ok(external_connections == 1, "external_connections = %d\n", external_connections);
3617
3618 expect_last_release_closes = TRUE;
3619 IStream_Seek(stream2, zero, STREAM_SEEK_SET, NULL);
3620 hres = CoReleaseMarshalData(stream2);
3621 ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
3622 ok(external_connections == 0, "external_connections = %d\n", external_connections);
3623
3624 IStream_Release(stream);
3625 IStream_Release(stream2);
3626
3627 /* Weak table marshaling does not increment external connections */
3628 hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
3629 ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
3630
3631 hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
3632 ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
3633 ok(external_connections == 0, "external_connections = %d\n", external_connections);
3634
3635 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3636 hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
3637 ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
3638 ok(external_connections == 0, "external_connections = %d\n", external_connections);
3639 ItestDual_Release(iface);
3640
3641 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3642 hres = CoReleaseMarshalData(stream);
3643 ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
3644 ok(external_connections == 0, "external_connections = %d\n", external_connections);
3645
3646 IStream_Release(stream);
3647}
TRUE
#define TRUE
Definition: types.h:120
CreateStreamOnHGlobal
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
Definition: hglobalstream.c:623
CoUnmarshalInterface
HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
Definition: marshal.c:1981
hres
HRESULT hres
Definition: protocol.c:465
todo_wine
#define todo_wine
Definition: custom.c:89
zero
int zero
Definition: sehframes.cpp:29
start_host_object
static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
Definition: tmarshal.c:155
end_host_object
static void end_host_object(DWORD tid, HANDLE thread)
Definition: tmarshal.c:172
_LARGE_INTEGER
Definition: typedefs.h:103

Referenced by START_TEST().

◆ test_libattr()

static void test_libattr ( void  )
static

Definition at line 3509 of file tmarshal.c.

3510{
3511 ITypeLib *pTypeLib;
3512 HRESULT hr;
3513 TLIBATTR *pattr;
3514
3515 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
3516 ok_ole_success(hr, LoadRegTypeLib);
3517 if (FAILED(hr))
3518 return;
3519
3520 hr = ITypeLib_GetLibAttr(pTypeLib, &pattr);
3521 ok_ole_success(hr, GetLibAttr);
3522 if (SUCCEEDED(hr))
3523 {
3524 ok(pattr->lcid == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), "lcid %x\n", pattr->lcid);
3525
3526 ITypeLib_ReleaseTLibAttr(pTypeLib, pattr);
3527 }
3528
3529 ITypeLib_Release(pTypeLib);
3530}
LANG_NEUTRAL
#define LANG_NEUTRAL
Definition: nls.h:22
MAKELANGID
#define MAKELANGID(p, s)
Definition: nls.h:15
SUBLANG_NEUTRAL
#define SUBLANG_NEUTRAL
Definition: nls.h:167

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.

2582{
2583 VARIANT var_in[2], var_out[2], var_in_out[2];
2584 ISomethingFromDispatch *proxy_sfd;
2585 array_t in, out, in_out;
2586 MYSTRUCT struct_in[2];
2587 HRESULT hr;
2588 int i = 2;
2589
2590 memcpy(in, test_array1, sizeof(array_t));
2591 memcpy(out, test_array2, sizeof(array_t));
2592 memcpy(in_out, test_array3, sizeof(array_t));
2593 hr = IWidget_array(widget, in, out, in_out);
2594 ok(hr == S_OK, "Got hr %#x.\n", hr);
2595 ok(!memcmp(&in, &test_array1, sizeof(array_t)), "Arrays didn't match.\n");
2596 ok(!memcmp(&out, &test_array5, sizeof(array_t)), "Arrays didn't match.\n");
2597 ok(!memcmp(&in_out, &test_array6, sizeof(array_t)), "Arrays didn't match.\n");
2598
2599 V_VT(&var_in[0]) = VT_I4; V_I4(&var_in[0]) = 1;
2600 V_VT(&var_in[1]) = VT_BYREF|VT_I4; V_I4REF(&var_in[1]) = &i;
2601 V_VT(&var_out[0]) = VT_I4; V_I4(&var_out[0]) = 3;
2602 V_VT(&var_out[1]) = VT_I4; V_I4(&var_out[1]) = 4;
2603 V_VT(&var_in_out[0]) = VT_I4; V_I4(&var_in_out[0]) = 5;
2604 V_VT(&var_in_out[1]) = VT_BSTR; V_BSTR(&var_in_out[1]) = SysAllocString(test_bstr1);
2605 hr = IWidget_variant_array(widget, var_in, var_out, var_in_out);
2606 ok(hr == S_OK, "Got hr %#x.\n", hr);
2607 ok(V_VT(&var_in[0]) == VT_I4, "Got wrong type %u.\n", V_VT(&var_in[0]));
2608 ok(V_I4(&var_in[0]) == 1, "Got wrong value %d.\n", V_I4(&var_in[0]));
2609 ok(V_VT(&var_in[1]) == (VT_BYREF|VT_I4), "Got wrong type %u.\n", V_VT(&var_in[1]));
2610 ok(V_I4REF(&var_in[1]) == &i, "Got wrong value %p.\n", V_I4REF(&var_in[1]));
2611 ok(i == 2, "Got wrong value %d.\n", i);
2612 ok(V_VT(&var_out[0]) == VT_I1, "Got wrong type %u.\n", V_VT(&var_out[0]));
2613 ok(V_I1(&var_out[0]) == 9, "Got wrong value %u.\n", V_VT(&var_out[0]));
2614 ok(V_VT(&var_out[1]) == VT_BSTR, "Got wrong type %u.\n", V_VT(&var_out[1]));
2615 ok(!lstrcmpW(V_BSTR(&var_out[1]), test_bstr2), "Got wrong value %s.\n", wine_dbgstr_w(V_BSTR(&var_out[1])));
2616 ok(V_VT(&var_in_out[0]) == VT_I1, "Got wrong type %u.\n", V_VT(&var_in_out[0]));
2617 ok(V_I1(&var_in_out[0]) == 11, "Got wrong value %u.\n", V_VT(&var_in_out[0]));
2618 ok(V_VT(&var_in_out[1]) == VT_UNKNOWN, "Got wrong type %u.\n", V_VT(&var_in_out[1]));
2619 hr = IUnknown_QueryInterface(V_UNKNOWN(&var_in_out[1]), &IID_ISomethingFromDispatch, (void **)&proxy_sfd);
2620 ok(hr == S_OK, "Got hr %#x.\n", hr);
2621 hr = ISomethingFromDispatch_anotherfn(proxy_sfd);
2622 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2623 ISomethingFromDispatch_Release(proxy_sfd);
2624 release_iface(V_UNKNOWN(&var_in_out[1]));
2625
2626 memcpy(&struct_in[0], &test_mystruct1, sizeof(MYSTRUCT));
2627 memcpy(&struct_in[1], &test_mystruct2, sizeof(MYSTRUCT));
2628 hr = IWidget_mystruct_array(widget, struct_in);
2629 ok(hr == S_OK, "Got hr %#x.\n", hr);
2630}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
VT_UNKNOWN
@ VT_UNKNOWN
Definition: compat.h:2308
VT_I1
@ VT_I1
Definition: compat.h:2310
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4242
in
GLuint in
Definition: glext.h:9616
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
TestTypelib::array_t
int array_t[4]
Definition: tmarshal.idl:109
TestTypelib::MYSTRUCT
struct TestTypelib::tagMYSTRUCT MYSTRUCT
V_UNKNOWN
#define V_UNKNOWN(A)
Definition: oleauto.h:281
V_I1
#define V_I1(A)
Definition: oleauto.h:243
V_I4
#define V_I4(A)
Definition: oleauto.h:247
V_I4REF
#define V_I4REF(A)
Definition: oleauto.h:248
release_iface
#define release_iface(a)
Definition: tmarshal.c:43
test_array2
static const array_t test_array2
Definition: tmarshal.c:72
test_array3
static const array_t test_array3
Definition: tmarshal.c:73
test_mystruct2
static const MYSTRUCT test_mystruct2
Definition: tmarshal.c:54
test_array1
static const array_t test_array1
Definition: tmarshal.c:71
test_mystruct1
static const MYSTRUCT test_mystruct1
Definition: tmarshal.c:53
test_array6
static const array_t test_array6
Definition: tmarshal.c:76
test_bstr2
static const WCHAR test_bstr2[]
Definition: tmarshal.c:49
test_array5
static const array_t test_array5
Definition: tmarshal.c:75
test_bstr1
static const WCHAR test_bstr1[]
Definition: tmarshal.c:48

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.

1946{
1947 VARIANTARG arg[11];
1948 DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
1949 HRESULT hr;
1950
1951 signed char c;
1952 short s;
1953 int i, i2, *pi;
1954 hyper h;
1955 unsigned char uc;
1956 unsigned short us;
1957 unsigned int ui;
1958 MIDL_uhyper uh;
1959 float f;
1960 double d;
1961 STATE st;
1962
1963 V_VT(&arg[10]) = VT_I1; V_I1(&arg[10]) = 5;
1964 V_VT(&arg[9]) = VT_I2; V_I2(&arg[9]) = -123;
1965 V_VT(&arg[8]) = VT_I4; V_I4(&arg[8]) = -100000;
1966 V_VT(&arg[7]) = VT_I8; V_I8(&arg[7]) = (LONGLONG)-100000 * 1000000;
1967 V_VT(&arg[6]) = VT_UI1; V_UI1(&arg[6]) = 0;
1968 V_VT(&arg[5]) = VT_UI2; V_UI2(&arg[5]) = 456;
1969 V_VT(&arg[4]) = VT_UI4; V_UI4(&arg[4]) = 0xdeadbeef;
1970 V_VT(&arg[3]) = VT_UI8; V_UI8(&arg[3]) = (ULONGLONG)1234567890 * 9876543210;
1971 V_VT(&arg[2]) = VT_R4; V_R4(&arg[2]) = M_PI;
1972 V_VT(&arg[1]) = VT_R8; V_R8(&arg[1]) = M_E;
1973 V_VT(&arg[0]) = VT_I4; V_I4(&arg[0]) = STATE_WIDGETIFIED;
1974 hr = IDispatch_Invoke(disp, DISPID_TM_BASETYPES_IN, &IID_NULL, LOCALE_NEUTRAL,
1975 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1976 ok(hr == S_OK, "Got hr %#x.\n", hr);
1977
1978 hr = IWidget_basetypes_in(widget, 5, -123, -100000, (LONGLONG)-100000 * 1000000, 0, 456,
1979 0xdeadbeef, (ULONGLONG)1234567890 * 9876543210, M_PI, M_E, STATE_WIDGETIFIED);
1980 ok(hr == S_OK, "Got hr %#x.\n", hr);
1981
1982 c = s = i = h = uc = us = ui = uh = f = d = st = 0;
1983
1984 V_VT(&arg[10]) = VT_BYREF|VT_I1; V_I1REF(&arg[10]) = &c;
1985 V_VT(&arg[9]) = VT_BYREF|VT_I2; V_I2REF(&arg[9]) = &s;
1986 V_VT(&arg[8]) = VT_BYREF|VT_I4; V_I4REF(&arg[8]) = &i;
1987 V_VT(&arg[7]) = VT_BYREF|VT_I8; V_I8REF(&arg[7]) = &h;
1988 V_VT(&arg[6]) = VT_BYREF|VT_UI1; V_UI1REF(&arg[6]) = &uc;
1989 V_VT(&arg[5]) = VT_BYREF|VT_UI2; V_UI2REF(&arg[5]) = &us;
1990 V_VT(&arg[4]) = VT_BYREF|VT_UI4; V_UI4REF(&arg[4]) = &ui;
1991 V_VT(&arg[3]) = VT_BYREF|VT_UI8; V_UI8REF(&arg[3]) = &uh;
1992 V_VT(&arg[2]) = VT_BYREF|VT_R4; V_R4REF(&arg[2]) = &f;
1993 V_VT(&arg[1]) = VT_BYREF|VT_R8; V_R8REF(&arg[1]) = &d;
1994 V_VT(&arg[0]) = VT_BYREF|VT_I4; V_I4REF(&arg[0]) = (int *)&st;
1995 hr = IDispatch_Invoke(disp, DISPID_TM_BASETYPES_OUT, &IID_NULL, LOCALE_NEUTRAL,
1996 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1997 ok(hr == S_OK, "Got hr %#x.\n", hr);
1998 ok(c == 10, "Got char %d.\n", c);
1999 ok(s == -321, "Got short %d.\n", s);
2000 ok(i == -200000, "Got int %d.\n", i);
2001 ok(h == (LONGLONG)-200000 * 1000000L, "Got hyper %s.\n", wine_dbgstr_longlong(h));
2002 ok(uc == 254, "Got unsigned char %u.\n", uc);
2003 ok(us == 256, "Got unsigned short %u.\n", us);
2004 ok(ui == 0xf00dfade, "Got unsigned int %i.\n", ui);
2005 ok(uh == ((((ULONGLONG)0xabcdef01) << 32) | (ULONGLONG)0x23456789),
2006 "Got unsigned hyper %s.\n", wine_dbgstr_longlong(uh));
2007 ok(f == (float)M_LN2, "Got float %f.\n", f);
2008 ok(d == M_LN10, "Got double %f.\n", d);
2009 ok(st == STATE_UNWIDGETIFIED, "Got state %u.\n", st);
2010
2011 c = s = i = h = uc = us = ui = uh = f = d = st = 0;
2012
2013 hr = IWidget_basetypes_out(widget, &c, &s, &i, &h, &uc, &us, &ui, &uh, &f, &d, &st);
2014 ok(hr == S_OK, "Got hr %#x.\n", hr);
2015 ok(c == 10, "Got char %d.\n", c);
2016 ok(s == -321, "Got short %d.\n", s);
2017 ok(i == -200000, "Got int %d.\n", i);
2018 ok(h == (LONGLONG)-200000 * 1000000L, "Got hyper %s.\n", wine_dbgstr_longlong(h));
2019 ok(uc == 254, "Got unsigned char %u.\n", uc);
2020 ok(us == 256, "Got unsigned short %u.\n", us);
2021 ok(ui == 0xf00dfade, "Got unsigned int %i.\n", ui);
2022 ok(uh == ((((ULONGLONG)0xabcdef01) << 32) | (ULONGLONG)0x23456789),
2023 "Got unsigned hyper %s.\n", wine_dbgstr_longlong(uh));
2024 ok(f == (float)M_LN2, "Got float %f.\n", f);
2025 ok(d == M_LN10, "Got double %f.\n", d);
2026 ok(st == STATE_UNWIDGETIFIED, "Got state %u.\n", st);
2027
2028 /* Test marshalling of public typedefs. */
2029
2030 i = 456;
2031 i2 = 789;
2032 pi = &i2;
2033 hr = IWidget_myint(widget, 123, &i, &pi);
2034 ok(hr == S_OK, "Got hr %#x.\n", hr);
2035
2036 /* Test that different float ABIs are correctly handled. */
2037
2038 hr = IWidget_float_abi(widget, 1.0f, 2.0, 3, 4.0f, 5.0);
2039 ok(hr == S_OK, "Got hr %#x.\n", hr);
2040}
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
VT_UI8
@ VT_UI8
Definition: compat.h:2315
VT_R4
@ VT_R4
Definition: compat.h:2299
VT_UI2
@ VT_UI2
Definition: compat.h:2312
VT_I8
@ VT_I8
Definition: compat.h:2314
VT_I2
@ VT_I2
Definition: compat.h:2297
VT_UI1
@ VT_UI1
Definition: compat.h:2311
s
GLdouble s
Definition: gl.h:2039
c
const GLubyte * c
Definition: glext.h:8905
f
GLfloat f
Definition: glext.h:7540
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
d
#define d
Definition: ke_i.h:81
f
#define f
Definition: ke_i.h:83
c
#define c
Definition: ke_i.h:80
M_PI
#define M_PI
Definition: macros.h:263
us
static const BYTE us[]
Definition: encode.c:689
pi
static refpint_t pi[]
Definition: server.c:96
TestTypelib::STATE_WIDGETIFIED
@ STATE_WIDGETIFIED
Definition: tmarshal.idl:97
stdole::DISPPARAMS
struct stdole::DISPPARAMS DISPPARAMS
V_UI1
#define V_UI1(A)
Definition: oleauto.h:266
V_I8
#define V_I8(A)
Definition: oleauto.h:249
V_UI2REF
#define V_UI2REF(A)
Definition: oleauto.h:269
V_R4REF
#define V_R4REF(A)
Definition: oleauto.h:261
V_UI4REF
#define V_UI4REF(A)
Definition: oleauto.h:271
V_UI2
#define V_UI2(A)
Definition: oleauto.h:268
DISPATCH_METHOD
#define DISPATCH_METHOD
Definition: oleauto.h:1006
V_I8REF
#define V_I8REF(A)
Definition: oleauto.h:250
V_UI8REF
#define V_UI8REF(A)
Definition: oleauto.h:273
ui
UINT ui
Definition: oleauto.h:49
V_R4
#define V_R4(A)
Definition: oleauto.h:260
V_UI4
#define V_UI4(A)
Definition: oleauto.h:270
V_I2REF
#define V_I2REF(A)
Definition: oleauto.h:246
V_UI1REF
#define V_UI1REF(A)
Definition: oleauto.h:267
V_I1REF
#define V_I1REF(A)
Definition: oleauto.h:244
V_UI8
#define V_UI8(A)
Definition: oleauto.h:272
V_R8REF
#define V_R8REF(A)
Definition: oleauto.h:263
V_I2
#define V_I2(A)
Definition: oleauto.h:245
IID_NULL
#define IID_NULL
Definition: guiddef.h:98
MIDL_uhyper
UINT64 MIDL_uhyper
Definition: rpcndr.h:118
hyper
INT64 hyper
Definition: rpcndr.h:117
STATE
Definition: userinit.h:57
DISPID_TM_BASETYPES_OUT
@ DISPID_TM_BASETYPES_OUT
Definition: tmarshal.idl:54
DISPID_TM_BASETYPES_IN
@ DISPID_TM_BASETYPES_IN
Definition: tmarshal.idl:53
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
arg
void * arg
Definition: msvc.h:10

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.

2395{
2396 VARIANTARG arg[4];
2397 DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
2398 BSTR in, out, in_ptr, in_out;
2399 HRESULT hr;
2400 UINT len;
2401
2402 testmode = 0;
2403 in = SysAllocStringLen(test_bstr1, ARRAY_SIZE(test_bstr1));
2404 out = NULL;
2405 in_ptr = SysAllocString(test_bstr2);
2406 in_out = SysAllocString(test_bstr3);
2407
2408 V_VT(&arg[3]) = VT_BSTR; V_BSTR(&arg[3]) = in;
2409 V_VT(&arg[2]) = VT_BSTR|VT_BYREF; V_BSTRREF(&arg[2]) = &out;
2410 V_VT(&arg[1]) = VT_BSTR|VT_BYREF; V_BSTRREF(&arg[1]) = &in_ptr;
2411 V_VT(&arg[0]) = VT_BSTR|VT_BYREF; V_BSTRREF(&arg[0]) = &in_out;
2412 hr = IDispatch_Invoke(disp, DISPID_TM_BSTR, &IID_NULL, LOCALE_NEUTRAL,
2413 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2414 ok(hr == S_OK, "Got hr %#x.\n", hr);
2415 ok(in[1] == test_bstr1[1], "[in] parameter should not be changed.\n");
2416 ok(in_ptr[1] == 'X', "[in] pointer should be changed.\n");
2417 ok(in_out[1] == 'X', "[in, out] parameter should be changed.\n");
2418 len = SysStringLen(out);
2419 ok(len == lstrlenW(test_bstr4), "Got wrong length %d.\n", len);
2420 ok(!memcmp(out, test_bstr4, len), "Got string %s.\n", wine_dbgstr_wn(out, len));
2421
2422 in[1] = test_bstr1[1];
2423 in_ptr[1] = test_bstr2[1];
2424 in_out[1] = test_bstr3[1];
2425 SysFreeString(out);
2426 out = (BSTR)0xdeadbeef;
2427 hr = IWidget_bstr(widget, in, &out, &in_ptr, &in_out);
2428 ok(hr == S_OK, "Got hr %#x.\n", hr);
2429 ok(in[1] == test_bstr1[1], "[in] parameter should not be changed.\n");
2430 ok(in_ptr[1] == test_bstr2[1], "[in] pointer should not be changed.\n");
2431 ok(in_out[1] == 'X', "[in, out] parameter should be changed.\n");
2432 len = SysStringLen(out);
2433 ok(len == lstrlenW(test_bstr4), "Got wrong length %d.\n", len);
2434 ok(!memcmp(out, test_bstr4, len), "Got string %s.\n", wine_dbgstr_wn(out, len));
2435 SysFreeString(in);
2436 SysFreeString(out);
2437 SysFreeString(in_ptr);
2438 SysFreeString(in_out);
2439
2440 testmode = 1;
2441 out = in_ptr = in_out = NULL;
2442 hr = IWidget_bstr(widget, NULL, &out, &in_ptr, &in_out);
2443 ok(hr == S_OK, "Got hr %#x.\n", hr);
2444}
wine_dbgstr_wn
const char * wine_dbgstr_wn(const WCHAR *str, int n)
Definition: compat.c:367
lstrlenW
#define lstrlenW
Definition: compat.h:750
UINT
unsigned int UINT
Definition: ndis.h:50
SysStringLen
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
SysAllocStringLen
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
testmode
static int testmode
Definition: tmarshal.c:662
test_bstr3
static const WCHAR test_bstr3[]
Definition: tmarshal.c:50
test_bstr4
static const WCHAR test_bstr4[]
Definition: tmarshal.c:51
DISPID_TM_BSTR
@ DISPID_TM_BSTR
Definition: tmarshal.idl:61

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.

2633{
2634 VARIANTARG arg[3];
2635 DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
2636 struct coclass_obj *class1, *class2, *class3;
2637 IUnknown *unk_in, *unk_out, *unk_in_out;
2638 ICoclass1 *in, *out, *in_out;
2639 HRESULT hr;
2640
2641 class1 = create_coclass_obj();
2642 class2 = create_coclass_obj();
2643 class3 = create_coclass_obj();
2644
2645 hr = IWidget_Coclass(widget, (Coclass1 *)&class1->ICoclass1_iface,
2646 (Coclass2 *)&class2->ICoclass1_iface, (Coclass3 *)&class3->ICoclass1_iface);
2647 ok(hr == S_OK, "Got hr %#x.\n", hr);
2648
2649 hr = IWidget_Coclass(widget, (Coclass1 *)&class1->ICoclass2_iface,
2650 (Coclass2 *)&class2->ICoclass2_iface, (Coclass3 *)&class3->ICoclass2_iface);
2651 ok(hr == S_OK, "Got hr %#x.\n", hr);
2652
2653 release_iface(&class1->ICoclass1_iface);
2654 release_iface(&class2->ICoclass1_iface);
2655 release_iface(&class3->ICoclass1_iface);
2656
2657 testmode = 0;
2658 class1 = create_coclass_obj();
2659 class2 = create_coclass_obj();
2660 class3 = create_coclass_obj();
2661 in = &class1->ICoclass1_iface;
2662 out = &class2->ICoclass1_iface;
2663 in_out = &class3->ICoclass1_iface;
2664 hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in, (Coclass1 **)&out, (Coclass1 **)&in_out);
2665 ok(hr == S_OK, "Got hr %#x.\n", hr);
2666 ok(in == &class1->ICoclass1_iface, "[in] parameter should not have changed.\n");
2667 ok(!out, "[out] parameter should have been cleared.\n");
2668 ok(in_out == &class3->ICoclass1_iface, "[in, out] parameter should not have changed.\n");
2669 release_iface(&class1->ICoclass1_iface);
2670 release_iface(&class2->ICoclass1_iface);
2671 release_iface(&class3->ICoclass1_iface);
2672
2673 testmode = 1;
2674 class1 = create_coclass_obj();
2675 class3 = create_coclass_obj();
2676 in = &class1->ICoclass1_iface;
2677 in_out = &class3->ICoclass1_iface;
2678 ICoclass1_AddRef(in_out);
2679 hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in,
2680 (Coclass1 **)&out, (Coclass1 **)&in_out);
2681 ok(hr == S_OK, "Got hr %#x.\n", hr);
2682 hr = ICoclass1_test(out);
2683 ok(hr == 1, "Got hr %#x.\n", hr);
2684 ok(in_out != &class3->ICoclass1_iface, "[in, out] parameter should have changed.\n");
2685 hr = ICoclass1_test(in_out);
2686 ok(hr == 1, "Got hr %#x.\n", hr);
2687 release_iface(out);
2688 release_iface(in_out);
2689 release_iface(&class1->ICoclass1_iface);
2690 release_iface(&class3->ICoclass1_iface);
2691
2692 testmode = 2;
2693 in = out = in_out = NULL;
2694 hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in,
2695 (Coclass1 **)&out, (Coclass1 **)&in_out);
2696 ok(hr == S_OK, "Got hr %#x.\n", hr);
2697 hr = ICoclass1_test(in_out);
2698 ok(hr == 1, "Got hr %#x.\n", hr);
2699 release_iface(in_out);
2700
2701 testmode = 3;
2702 in = out = NULL;
2703 class3 = create_coclass_obj();
2704 in_out = &class3->ICoclass1_iface;
2705 hr = IWidget_Coclass_ptr(widget, (Coclass1 **)&in,
2706 (Coclass1 **)&out, (Coclass1 **)&in_out);
2707 ok(hr == S_OK, "Got hr %#x.\n", hr);
2708 ok(!in_out, "Got [in, out] %p.\n", in_out);
2709
2710 /* Test with Invoke(). Note that since we pass VT_UNKNOWN, we don't get our
2711 * interface back, but rather an IUnknown. */
2712
2713 class1 = create_coclass_obj();
2714 class2 = create_coclass_obj();
2715 class3 = create_coclass_obj();
2716
2717 V_VT(&arg[2]) = VT_UNKNOWN; V_UNKNOWN(&arg[2]) = (IUnknown *)&class1->ICoclass1_iface;
2718 V_VT(&arg[1]) = VT_UNKNOWN; V_UNKNOWN(&arg[1]) = (IUnknown *)&class2->ICoclass1_iface;
2719 V_VT(&arg[0]) = VT_UNKNOWN; V_UNKNOWN(&arg[0]) = (IUnknown *)&class3->ICoclass1_iface;
2720 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL,
2721 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2722 ok(hr == S_OK, "Got hr %#x.\n", hr);
2723
2724 V_VT(&arg[2]) = VT_UNKNOWN; V_UNKNOWN(&arg[2]) = (IUnknown *)&class1->ICoclass2_iface;
2725 V_VT(&arg[1]) = VT_UNKNOWN; V_UNKNOWN(&arg[1]) = (IUnknown *)&class2->ICoclass2_iface;
2726 V_VT(&arg[0]) = VT_UNKNOWN; V_UNKNOWN(&arg[0]) = (IUnknown *)&class3->ICoclass2_iface;
2727 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL,
2728 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2729 ok(hr == S_OK, "Got hr %#x.\n", hr);
2730
2731 V_VT(&arg[2]) = VT_DISPATCH; V_DISPATCH(&arg[2]) = (IDispatch *)&class1->ICoclass1_iface;
2732 V_VT(&arg[1]) = VT_DISPATCH; V_DISPATCH(&arg[1]) = (IDispatch *)&class2->ICoclass1_iface;
2733 V_VT(&arg[0]) = VT_DISPATCH; V_DISPATCH(&arg[0]) = (IDispatch *)&class3->ICoclass1_iface;
2734 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL,
2735 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2736 ok(hr == S_OK, "Got hr %#x.\n", hr);
2737
2738 release_iface(&class1->ICoclass1_iface);
2739 release_iface(&class2->ICoclass1_iface);
2740 release_iface(&class3->ICoclass1_iface);
2741
2742 testmode = 0;
2743 class1 = create_coclass_obj();
2744 class3 = create_coclass_obj();
2745 unk_in = (IUnknown *)&class1->ICoclass1_iface;
2746 unk_out = NULL;
2747 unk_in_out = (IUnknown *)&class3->ICoclass1_iface;
2748 V_VT(&arg[2]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[2]) = &unk_in;
2749 V_VT(&arg[1]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[1]) = &unk_out;
2750 V_VT(&arg[0]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[0]) = &unk_in_out;
2751 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
2752 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2753todo_wine
2754 ok(hr == S_OK, "Got hr %#x.\n", hr);
2755 ok(unk_in == (IUnknown *)&class1->ICoclass1_iface, "[in] parameter should not have changed.\n");
2756 ok(!unk_out, "[out] parameter should have been cleared.\n");
2757 ok(unk_in_out == (IUnknown *)&class3->ICoclass1_iface, "[in, out] parameter should not have changed.\n");
2758 release_iface(&class1->ICoclass1_iface);
2759 release_iface(&class3->ICoclass1_iface);
2760
2761 testmode = 1;
2762 class1 = create_coclass_obj();
2763 class3 = create_coclass_obj();
2764 unk_in = (IUnknown *)&class1->ICoclass1_iface;
2765 unk_out = NULL;
2766 unk_in_out = (IUnknown *)&class3->ICoclass1_iface;
2767 IUnknown_AddRef(unk_in_out);
2768 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
2769 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2770todo_wine
2771 ok(hr == S_OK, "Got hr %#x.\n", hr);
2772
2773if (hr == S_OK) {
2774 hr = IUnknown_QueryInterface(unk_out, &IID_ICoclass1, (void **)&out);
2775 ok(hr == S_OK, "Got hr %#x.\n", hr);
2776 hr = ICoclass1_test(out);
2777 ok(hr == 1, "Got hr %#x.\n", hr);
2778 ICoclass1_Release(out);
2779
2780 ok(unk_in_out != (IUnknown *)&class3->ICoclass1_iface, "[in, out] parameter should have changed.\n");
2781 hr = IUnknown_QueryInterface(unk_in_out, &IID_ICoclass1, (void **)&in_out);
2782 ok(hr == S_OK, "Got hr %#x.\n", hr);
2783 hr = ICoclass1_test(in_out);
2784 ok(hr == 1, "Got hr %#x.\n", hr);
2785 ICoclass1_Release(in_out);
2786
2787 release_iface(unk_out);
2788 release_iface(unk_in_out);
2789}
2790 release_iface(&class1->ICoclass1_iface);
2791todo_wine
2792 release_iface(&class3->ICoclass1_iface);
2793
2794 testmode = 2;
2795 unk_in = unk_out = unk_in_out = NULL;
2796 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
2797 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2798todo_wine
2799 ok(hr == S_OK, "Got hr %#x.\n", hr);
2800
2801 ok(!unk_out, "[out] parameter should not have been set.\n");
2802if (hr == S_OK) {
2803 hr = IUnknown_QueryInterface(unk_in_out, &IID_ICoclass1, (void **)&in_out);
2804 ok(hr == S_OK, "Got hr %#x.\n", hr);
2805 hr = ICoclass1_test(in_out);
2806 ok(hr == 1, "Got hr %#x.\n", hr);
2807 ICoclass1_Release(in_out);
2808
2809 release_iface(unk_in_out);
2810}
2811
2812 testmode = 3;
2813 unk_in = unk_out = NULL;
2814 class3 = create_coclass_obj();
2815 unk_in_out = (IUnknown *)&class3->ICoclass1_iface;
2816 IUnknown_AddRef(unk_in_out);
2817 hr = IDispatch_Invoke(disp, DISPID_TM_COCLASS_PTR, &IID_NULL, LOCALE_NEUTRAL,
2818 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2819todo_wine
2820 ok(hr == S_OK, "Got hr %#x.\n", hr);
2821todo_wine
2822 ok(!unk_in_out, "[in, out] parameter should have been cleared.\n");
2823
2824todo_wine
2825 release_iface(&class3->ICoclass1_iface);
2826}
VT_DISPATCH
@ VT_DISPATCH
Definition: compat.h:2304
unk_in
static RefUnk unk_in
Definition: misc.c:2110
unk_out
static RefUnk unk_out
Definition: misc.c:2110
V_UNKNOWNREF
#define V_UNKNOWNREF(A)
Definition: oleauto.h:282
V_DISPATCH
#define V_DISPATCH(A)
Definition: oleauto.h:239
coclass_obj::ICoclass1_iface
ICoclass1 ICoclass1_iface
Definition: tmarshal.c:494
coclass_obj::ICoclass2_iface
ICoclass2 ICoclass2_iface
Definition: tmarshal.c:495
create_coclass_obj
static struct coclass_obj * create_coclass_obj(void)
Definition: tmarshal.c:653
DISPID_TM_COCLASS_PTR
@ DISPID_TM_COCLASS_PTR
Definition: tmarshal.idl:74
DISPID_TM_COCLASS
#define DISPID_TM_COCLASS
Definition: tmarshal_dispids.h:51

Referenced by test_typelibmarshal().

◆ test_marshal_dispinterface()

static void test_marshal_dispinterface ( void  )
static

Definition at line 3649 of file tmarshal.c.

3650{
3651 static const LARGE_INTEGER zero;
3652
3653 ISomethingFromDispatch *disp_obj = create_disp_obj();
3654 ITypeInfo *typeinfo = NULL;
3655 IDispatch *proxy_disp;
3656 IStream *stream;
3657 HANDLE thread;
3658 HRESULT hr;
3659 ULONG ref;
3660 DWORD tid;
3661
3662 CreateStreamOnHGlobal(NULL, TRUE, &stream);
3663 tid = start_host_object(stream, &DIID_ItestIF4, (IUnknown *)disp_obj, MSHLFLAGS_NORMAL, &thread);
3664 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
3665 hr = CoUnmarshalInterface(stream, &DIID_ItestIF4, (void **)&proxy_disp);
3666 ok(hr == S_OK, "Got hr %#x.\n", hr);
3667
3668 hr = IDispatch_GetTypeInfo(proxy_disp, 0xdeadbeef, 0, &typeinfo);
3669 ok(hr == 0xbeefdead, "Got hr %#x.\n", hr);
3670
3671 ref = IDispatch_Release(proxy_disp);
3672 ok(!ref, "Got outstanding refcount %d.\n", ref);
3673 ref = IStream_Release(stream);
3674 ok(!ref, "Got outstanding refcount %d.\n", ref);
3675 end_host_object(tid, thread);
3676 ref = ISomethingFromDispatch_Release(disp_obj);
3677 ok(!ref, "Got outstanding refcount %d.\n", ref);
3678}
create_disp_obj
static ISomethingFromDispatch * create_disp_obj(void)
Definition: tmarshal.c:484

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.

2157{
2158 VARIANTARG arg[3];
2159 DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
2160 ISomethingFromDispatch *sfd1, *sfd2, *sfd3, *proxy_sfd, *sfd_in, *sfd_out, *sfd_in_out;
2161 IUnknown *proxy_unk, *proxy_unk2, *unk_in, *unk_out, *unk_in_out;
2162 IDispatch *proxy_disp;
2163 HRESULT hr;
2164
2165 testmode = 0;
2166 sfd1 = create_disp_obj();
2167 sfd2 = create_disp_obj();
2168 sfd3 = create_disp_obj();
2169 hr = IWidget_iface_in(widget, (IUnknown *)sfd1,
2170 (IDispatch *)sfd2, sfd3);
2171 ok(hr == S_OK, "Got hr %#x.\n", hr);
2172 release_iface(sfd1);
2173 release_iface(sfd2);
2174 release_iface(sfd3);
2175
2176 testmode = 1;
2177 hr = IWidget_iface_in(widget, NULL, NULL, NULL);
2178 ok(hr == S_OK, "Got hr %#x.\n", hr);
2179
2180 testmode = 0;
2181 proxy_unk = (IUnknown *)0xdeadbeef;
2182 proxy_disp = (IDispatch *)0xdeadbeef;
2183 proxy_sfd = (ISomethingFromDispatch *)0xdeadbeef;
2184 hr = IWidget_iface_out(widget, &proxy_unk, &proxy_disp, &proxy_sfd);
2185 ok(hr == S_OK, "Got hr %#x.\n", hr);
2186 check_iface_marshal(proxy_unk, proxy_disp, proxy_sfd);
2187 release_iface(proxy_unk);
2188 release_iface(proxy_disp);
2189 release_iface(proxy_sfd);
2190
2191 testmode = 1;
2192 hr = IWidget_iface_out(widget, &proxy_unk, &proxy_disp, &proxy_sfd);
2193 ok(hr == S_OK, "Got hr %#x.\n", hr);
2194 ok(!proxy_unk, "Got unexpected proxy %p.\n", proxy_unk);
2195 ok(!proxy_disp, "Got unexpected proxy %p.\n", proxy_disp);
2196 ok(!proxy_sfd, "Got unexpected proxy %p.\n", proxy_sfd);
2197
2198 testmode = 0;
2199 sfd_in = sfd1 = create_disp_obj();
2200 sfd_out = sfd2 = create_disp_obj();
2201 sfd_in_out = sfd3 = create_disp_obj();
2202 hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
2203 ok(hr == S_OK, "Got hr %#x.\n", hr);
2204 ok(sfd_in == sfd1, "[in] parameter should not have changed.\n");
2205 ok(!sfd_out, "[out] parameter should have been cleared.\n");
2206 ok(sfd_in_out == sfd3, "[in, out] parameter should not have changed.\n");
2207 release_iface(sfd1);
2208 release_iface(sfd2);
2209 release_iface(sfd3);
2210
2211 testmode = 1;
2212 sfd_in = sfd1 = create_disp_obj();
2213 sfd_in_out = sfd3 = create_disp_obj();
2214 ISomethingFromDispatch_AddRef(sfd_in_out);
2215 hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
2216 ok(hr == S_OK, "Got hr %#x.\n", hr);
2217 hr = ISomethingFromDispatch_anotherfn(sfd_out);
2218 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2219 ok(sfd_in_out != sfd3, "[in, out] parameter should have changed.\n");
2220 hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
2221 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2222 release_iface(sfd_out);
2223 release_iface(sfd_in_out);
2224 release_iface(sfd1);
2225 release_iface(sfd3);
2226
2227 testmode = 2;
2228 sfd_in = sfd_out = sfd_in_out = NULL;
2229 hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
2230 ok(hr == S_OK, "Got hr %#x.\n", hr);
2231 ok(!sfd_out, "[out] parameter should not have been set.\n");
2232 hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
2233 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2234 release_iface(sfd_in_out);
2235
2236 testmode = 3;
2237 sfd_in = sfd_out = NULL;
2238 sfd_in_out = sfd3 = create_disp_obj();
2239 ISomethingFromDispatch_AddRef(sfd_in_out);
2240 hr = IWidget_iface_ptr(widget, &sfd_in, &sfd_out, &sfd_in_out);
2241 ok(hr == S_OK, "Got hr %#x.\n", hr);
2242 ok(!sfd_in_out, "Got [in, out] %p.\n", sfd_in_out);
2243 release_iface(sfd3);
2244
2245 /* Test with Invoke(). Note that since we pass VT_UNKNOWN, we don't get our
2246 * interface back, but rather an IUnknown. */
2247
2248 testmode = 0;
2249 sfd1 = create_disp_obj();
2250 sfd2 = create_disp_obj();
2251 sfd3 = create_disp_obj();
2252
2253 V_VT(&arg[2]) = VT_UNKNOWN; V_UNKNOWN(&arg[2]) = (IUnknown *)sfd1;
2254 V_VT(&arg[1]) = VT_UNKNOWN; V_UNKNOWN(&arg[1]) = (IUnknown *)sfd2;
2255 V_VT(&arg[0]) = VT_UNKNOWN; V_UNKNOWN(&arg[0]) = (IUnknown *)sfd3;
2256 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_IN, &IID_NULL, LOCALE_NEUTRAL,
2257 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2258 ok(hr == S_OK, "Got hr %#x.\n", hr);
2259
2260 V_VT(&arg[2]) = VT_DISPATCH; V_DISPATCH(&arg[2]) = (IDispatch *)sfd1;
2261 V_VT(&arg[1]) = VT_DISPATCH; V_DISPATCH(&arg[1]) = (IDispatch *)sfd2;
2262 V_VT(&arg[0]) = VT_DISPATCH; V_DISPATCH(&arg[0]) = (IDispatch *)sfd3;
2263 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_IN, &IID_NULL, LOCALE_NEUTRAL,
2264 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2265 ok(hr == S_OK, "Got hr %#x.\n", hr);
2266
2267 release_iface(sfd1);
2268 release_iface(sfd2);
2269 release_iface(sfd3);
2270
2271 testmode = 1;
2272 V_VT(&arg[2]) = VT_UNKNOWN; V_UNKNOWN(&arg[2]) = NULL;
2273 V_VT(&arg[1]) = VT_UNKNOWN; V_UNKNOWN(&arg[1]) = NULL;
2274 V_VT(&arg[0]) = VT_UNKNOWN; V_UNKNOWN(&arg[0]) = NULL;
2275 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_IN, &IID_NULL, LOCALE_NEUTRAL,
2276 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2277 ok(hr == S_OK, "Got hr %#x.\n", hr);
2278
2279 testmode = 0;
2280 proxy_unk = proxy_unk2 = NULL;
2281 proxy_disp = NULL;
2282 V_VT(&arg[2]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[2]) = &proxy_unk;
2283 V_VT(&arg[1]) = VT_DISPATCH|VT_BYREF; V_DISPATCHREF(&arg[1]) = &proxy_disp;
2284 V_VT(&arg[0]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[0]) = &proxy_unk2;
2285 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_OUT, &IID_NULL, LOCALE_NEUTRAL,
2286 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2287todo_wine
2288 ok(hr == S_OK, "Got hr %#x.\n", hr);
2289if (hr == S_OK) {
2290 hr = IUnknown_QueryInterface(proxy_unk2, &IID_ISomethingFromDispatch, (void **)&proxy_sfd);
2291 ok(hr == S_OK, "Got hr %#x.\n", hr);
2292 check_iface_marshal(proxy_unk, proxy_disp, proxy_sfd);
2293 ISomethingFromDispatch_Release(proxy_sfd);
2294 release_iface(proxy_unk);
2295 release_iface(proxy_disp);
2296 release_iface(proxy_unk2);
2297}
2298
2299 testmode = 1;
2300 proxy_unk = proxy_unk2 = NULL;
2301 proxy_disp = NULL;
2302 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_OUT, &IID_NULL, LOCALE_NEUTRAL,
2303 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2304todo_wine
2305 ok(hr == S_OK, "Got hr %#x.\n", hr);
2306 ok(!proxy_unk, "Got unexpected proxy %p.\n", proxy_unk);
2307 ok(!proxy_disp, "Got unexpected proxy %p.\n", proxy_disp);
2308 ok(!proxy_unk2, "Got unexpected proxy %p.\n", proxy_unk2);
2309
2310 testmode = 0;
2311 sfd1 = create_disp_obj();
2312 sfd3 = create_disp_obj();
2313 unk_in = (IUnknown *)sfd1;
2314 unk_out = NULL;
2315 unk_in_out = (IUnknown *)sfd3;
2316 V_VT(&arg[2]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[2]) = &unk_in;
2317 V_VT(&arg[1]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[1]) = &unk_out;
2318 V_VT(&arg[0]) = VT_UNKNOWN|VT_BYREF; V_UNKNOWNREF(&arg[0]) = &unk_in_out;
2319 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
2320 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2321todo_wine
2322 ok(hr == S_OK, "Got hr %#x.\n", hr);
2323 ok(unk_in == (IUnknown *)sfd1, "[in] parameter should not have changed.\n");
2324 ok(!unk_out, "[out] parameter should have been cleared.\n");
2325 ok(unk_in_out == (IUnknown *)sfd3, "[in, out] parameter should not have changed.\n");
2326 release_iface(sfd1);
2327 release_iface(sfd3);
2328
2329 testmode = 1;
2330 sfd1 = create_disp_obj();
2331 sfd3 = create_disp_obj();
2332 unk_in = (IUnknown *)sfd1;
2333 unk_out = NULL;
2334 unk_in_out = (IUnknown *)sfd3;
2335 IUnknown_AddRef(unk_in_out);
2336 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
2337 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2338todo_wine
2339 ok(hr == S_OK, "Got hr %#x.\n", hr);
2340
2341if (hr == S_OK) {
2342 hr = IUnknown_QueryInterface(unk_out, &IID_ISomethingFromDispatch, (void **)&sfd_out);
2343 ok(hr == S_OK, "Got hr %#x.\n", hr);
2344 hr = ISomethingFromDispatch_anotherfn(sfd_out);
2345 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2346 ISomethingFromDispatch_Release(sfd_out);
2347
2348 ok(unk_in_out != (IUnknown *)sfd3, "[in, out] parameter should have changed.\n");
2349 hr = IUnknown_QueryInterface(unk_in_out, &IID_ISomethingFromDispatch, (void **)&sfd_in_out);
2350 ok(hr == S_OK, "Got hr %#x.\n", hr);
2351 hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
2352 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2353 ISomethingFromDispatch_Release(sfd_in_out);
2354
2355 release_iface(unk_out);
2356 release_iface(unk_in_out);
2357}
2358 release_iface(sfd1);
2359todo_wine
2360 release_iface(sfd3);
2361
2362 testmode = 2;
2363 unk_in = unk_out = unk_in_out = NULL;
2364 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
2365 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2366todo_wine
2367 ok(hr == S_OK, "Got hr %#x.\n", hr);
2368
2369 ok(!unk_out, "[out] parameter should not have been set.\n");
2370if (hr == S_OK) {
2371 hr = IUnknown_QueryInterface(unk_in_out, &IID_ISomethingFromDispatch, (void **)&sfd_in_out);
2372 ok(hr == S_OK, "Got hr %#x.\n", hr);
2373 hr = ISomethingFromDispatch_anotherfn(sfd_in_out);
2374 ok(hr == 0x01234567, "Got hr %#x.\n", hr);
2375 ISomethingFromDispatch_Release(sfd_in_out);
2376
2377 release_iface(unk_in_out);
2378}
2379
2380 testmode = 3;
2381 unk_in = unk_out = NULL;
2382 sfd3 = create_disp_obj();
2383 unk_in_out = (IUnknown *)sfd3;
2384 IUnknown_AddRef(unk_in_out);
2385 hr = IDispatch_Invoke(disp, DISPID_TM_IFACE_PTR, &IID_NULL, LOCALE_NEUTRAL,
2386 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2387todo_wine {
2388 ok(hr == S_OK, "Got hr %#x.\n", hr);
2389 ok(!unk_in_out, "[in, out] parameter should have been cleared.\n");
2390 release_iface(sfd3);
2391}
2392}
V_DISPATCHREF
#define V_DISPATCHREF(A)
Definition: oleauto.h:240
check_iface_marshal
static void check_iface_marshal(IUnknown *unk, IDispatch *disp, ISomethingFromDispatch *sfd)
Definition: tmarshal.c:1212
DISPID_TM_IFACE_PTR
@ DISPID_TM_IFACE_PTR
Definition: tmarshal.idl:60
DISPID_TM_IFACE_OUT
@ DISPID_TM_IFACE_OUT
Definition: tmarshal.idl:59
DISPID_TM_IFACE_IN
@ DISPID_TM_IFACE_IN
Definition: tmarshal.idl:58

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.

2043{
2044 VARIANTARG arg[3];
2045 DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
2046 int in, out, in_out, *in_ptr, *out_ptr, *in_out_ptr;
2047 HRESULT hr;
2048
2049 testmode = 0;
2050
2051 in = 123;
2052 out = 456;
2053 in_out = 789;
2054 V_VT(&arg[2]) = VT_BYREF|VT_I4; V_I4REF(&arg[2]) = &in;
2055 V_VT(&arg[1]) = VT_BYREF|VT_I4; V_I4REF(&arg[1]) = &out;
2056 V_VT(&arg[0]) = VT_BYREF|VT_I4; V_I4REF(&arg[0]) = &in_out;
2057 hr = IDispatch_Invoke(disp, DISPID_TM_INT_PTR, &IID_NULL, LOCALE_NEUTRAL,
2058 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2059 ok(hr == S_OK, "Got hr %#x.\n", hr);
2060 ok(in == 987, "Got [in] %d.\n", in);
2061 ok(out == 654, "Got [out] %d.\n", out);
2062 ok(in_out == 321, "Got [in, out] %d.\n", in_out);
2063
2064 testmode = 1;
2065
2066 in = 123;
2067 out = 456;
2068 in_out = 789;
2069 hr = IWidget_int_ptr(widget, &in, &out, &in_out);
2070 ok(hr == S_OK, "Got hr %#x.\n", hr);
2071 ok(in == 123, "Got [in] %d.\n", in);
2072 ok(out == 654, "Got [out] %d.\n", out);
2073 ok(in_out == 321, "Got [in, out] %d.\n", in_out);
2074
2075 out = in_out = -1;
2076 hr = IWidget_int_ptr(widget, NULL, &out, &in_out);
2077 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
2078 ok(!out, "[out] parameter should have been cleared.\n");
2079 ok(in_out == -1, "[in, out] parameter should not have been cleared.\n");
2080
2081 in = in_out = -1;
2082 hr = IWidget_int_ptr(widget, &in, NULL, &in_out);
2083 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
2084 ok(in == -1, "[in] parameter should not have been cleared.\n");
2085 ok(in_out == -1, "[in, out] parameter should not have been cleared.\n");
2086
2087 in = out = -1;
2088 hr = IWidget_int_ptr(widget, &in, &out, NULL);
2089 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
2090 ok(in == -1, "[in] parameter should not have been cleared.\n");
2091 ok(!out, "[out] parameter should have been cleared.\n");
2092
2093 /* We can't test Invoke() with double pointers, as it is not possible to fit
2094 * more than one level of indirection into a VARIANTARG. */
2095
2096 testmode = 0;
2097 in_ptr = out_ptr = in_out_ptr = NULL;
2098 hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
2099 ok(hr == S_OK, "Got hr %#x\n", hr);
2100 ok(!in_ptr, "Got [in] %p.\n", in_ptr);
2101 ok(!out_ptr, "Got [out] %p.\n", out_ptr);
2102 ok(!in_out_ptr, "Got [in, out] %p.\n", in_out_ptr);
2103
2104 testmode = 1;
2105 hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
2106 ok(hr == S_OK, "Got hr %#x\n", hr);
2107 ok(*out_ptr == 654, "Got [out] %d.\n", *out_ptr);
2108 ok(*in_out_ptr == 321, "Got [in, out] %d.\n", *in_out_ptr);
2109 CoTaskMemFree(out_ptr);
2110 CoTaskMemFree(in_out_ptr);
2111
2112 testmode = 2;
2113 in = 123;
2114 out = 456;
2115 in_out = 789;
2116 in_ptr = &in;
2117 out_ptr = &out;
2118 in_out_ptr = &in_out;
2119 hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
2120 ok(hr == S_OK, "Got hr %#x.\n", hr);
2121 ok(out_ptr != &out, "[out] ptr should have changed.\n");
2122 ok(in_out_ptr == &in_out, "[in, out] ptr should not have changed.\n");
2123 ok(*out_ptr == 654, "Got [out] %d.\n", *out_ptr);
2124 ok(*in_out_ptr == 321, "Got [in, out] %d.\n", *in_out_ptr);
2125
2126 testmode = 3;
2127 in_ptr = out_ptr = NULL;
2128 in_out = 789;
2129 in_out_ptr = &in_out;
2130 hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, &in_out_ptr);
2131 ok(hr == S_OK, "Got hr %#x.\n", hr);
2132 ok(!in_out_ptr, "Got [in, out] %p.\n", in_out_ptr);
2133
2134 out_ptr = &out;
2135 in_out_ptr = &in_out;
2136 hr = IWidget_int_ptr_ptr(widget, NULL, &out_ptr, &in_out_ptr);
2137 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
2138 ok(!out_ptr, "[out] parameter should have been cleared.\n");
2139 ok(in_out_ptr == &in_out, "[in, out] parameter should not have been cleared.\n");
2140
2141 in_ptr = &in;
2142 in_out_ptr = &in_out;
2143 hr = IWidget_int_ptr_ptr(widget, &in_ptr, NULL, &in_out_ptr);
2144 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
2145 ok(in_ptr == &in, "[in] parameter should not have been cleared.\n");
2146 ok(in_out_ptr == &in_out, "[in, out] parameter should not have been cleared.\n");
2147
2148 in_ptr = &in;
2149 out_ptr = &out;
2150 hr = IWidget_int_ptr_ptr(widget, &in_ptr, &out_ptr, NULL);
2151 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "Got hr %#x.\n", hr);
2152 ok(in_ptr == &in, "[in] parameter should not have been cleared.\n");
2153 ok(!out_ptr, "[out] parameter should have been cleared.\n");
2154}
DISPID_TM_INT_PTR
@ DISPID_TM_INT_PTR
Definition: tmarshal.idl:56
RPC_X_NULL_REF_POINTER
#define RPC_X_NULL_REF_POINTER
Definition: winerror.h:1087
HRESULT_FROM_WIN32
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92

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.

2499{
2500 SAFEARRAY *in, *out, *out2, *in_ptr, *in_out;
2501 HRESULT hr;
2502
2503 in = make_safearray(3);
2504 out = out2 = make_safearray(5);
2505 in_ptr = make_safearray(7);
2506 in_out = make_safearray(9);
2507 hr = IWidget_safearray(widget, in, &out, &in_ptr, &in_out);
2508 ok(hr == S_OK, "Got hr %#x.\n", hr);
2509 check_safearray(in, 3);
2510 check_safearray(out, 4);
2511 check_safearray(out2, 5);
2512 check_safearray(in_ptr, 7);
2513 check_safearray(in_out, 6);
2514
2515 SafeArrayDestroy(in);
2516 SafeArrayDestroy(out);
2517 SafeArrayDestroy(out2);
2518 SafeArrayDestroy(in_ptr);
2519 SafeArrayDestroy(in_out);
2520}
SafeArrayDestroy
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
Definition: safearray.c:1347
check_safearray
static void check_safearray(SAFEARRAY *sa, LONG expect)
Definition: tmarshal.c:1367
make_safearray
static SAFEARRAY * make_safearray(ULONG len)
Definition: tmarshal.c:1354

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.

2523{
2524 MYSTRUCT out, in_ptr, in_out, *in_ptr_ptr;
2525 RECT rect_out, rect_in_ptr, rect_in_out;
2526 ISomethingFromDispatch *sfd;
2527 struct complex complex;
2528 int i, i2, *pi = &i2;
2529 HRESULT hr;
2530
2531 memcpy(&out, &test_mystruct2, sizeof(MYSTRUCT));
2532 memcpy(&in_ptr, &test_mystruct3, sizeof(MYSTRUCT));
2533 memcpy(&in_out, &test_mystruct4, sizeof(MYSTRUCT));
2534 hr = IWidget_mystruct(widget, test_mystruct1, &out, &in_ptr, &in_out);
2535 ok(hr == S_OK, "Got hr %#x.\n", hr);
2536 ok(!memcmp(&out, &test_mystruct5, sizeof(MYSTRUCT)), "Structs didn't match.\n");
2537 ok(!memcmp(&in_ptr, &test_mystruct3, sizeof(MYSTRUCT)), "Structs didn't match.\n");
2538 ok(!memcmp(&in_out, &test_mystruct7, sizeof(MYSTRUCT)), "Structs didn't match.\n");
2539
2540 memcpy(&in_ptr, &test_mystruct1, sizeof(MYSTRUCT));
2541 in_ptr_ptr = &in_ptr;
2542 hr = IWidget_mystruct_ptr_ptr(widget, &in_ptr_ptr);
2543 ok(hr == S_OK, "Got hr %#x.\n", hr);
2544
2545 /* Make sure that "thin" structs (<=8 bytes) are handled correctly in x86-64. */
2546
2547 hr = IWidget_thin_struct(widget, test_thin_struct);
2548 ok(hr == S_OK, "Got hr %#x.\n", hr);
2549
2550 /* Make sure we can handle an imported type. */
2551
2552 rect_out = test_rect2;
2553 rect_in_ptr = test_rect3;
2554 rect_in_out = test_rect4;
2555 hr = IWidget_rect(widget, test_rect1, &rect_out, &rect_in_ptr, &rect_in_out);
2556 ok(hr == S_OK, "Got hr %#x.\n", hr);
2557 ok(EqualRect(&rect_out, &test_rect5), "Rects didn't match.\n");
2558 ok(EqualRect(&rect_in_ptr, &test_rect3), "Rects didn't match.\n");
2559 ok(EqualRect(&rect_in_out, &test_rect7), "Rects didn't match.\n");
2560
2561 /* Test complex structs. */
2562 complex.c = 98;
2563 complex.i = 76543;
2564 i = 2;
2565 complex.pi = &i;
2566 i2 = 10;
2567 complex.ppi = &pi;
2568 complex.iface = create_disp_obj();
2569 sfd = create_disp_obj();
2570 complex.iface_ptr = &sfd;
2571 complex.bstr = SysAllocString(test_bstr2);
2572 V_VT(&complex.var) = VT_I4;
2573 V_I4(&complex.var) = 123;
2574 memcpy(&complex.mystruct, &test_mystruct1, sizeof(MYSTRUCT));
2575 memcpy(complex.arr, test_array1, sizeof(array_t));
2576 complex.myint = 456;
2577 hr = IWidget_complex_struct(widget, complex);
2578 ok(hr == S_OK, "Got hr %#x.\n", hr);
2579}
test_mystruct3
static const MYSTRUCT test_mystruct3
Definition: tmarshal.c:55
test_rect1
static const RECT test_rect1
Definition: tmarshal.c:63
test_rect5
static const RECT test_rect5
Definition: tmarshal.c:67
test_rect4
static const RECT test_rect4
Definition: tmarshal.c:66
test_rect2
static const RECT test_rect2
Definition: tmarshal.c:64
test_thin_struct
static const struct thin test_thin_struct
Definition: tmarshal.c:61
test_rect3
static const RECT test_rect3
Definition: tmarshal.c:65
test_mystruct4
static const MYSTRUCT test_mystruct4
Definition: tmarshal.c:56
test_mystruct7
static const MYSTRUCT test_mystruct7
Definition: tmarshal.c:59
test_mystruct5
static const MYSTRUCT test_mystruct5
Definition: tmarshal.c:57
test_rect7
static const RECT test_rect7
Definition: tmarshal.c:69
EqualRect
BOOL WINAPI EqualRect(_In_ LPCRECT, _In_ LPCRECT)

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.

2447{
2448 VARIANTARG arg[4];
2449 DISPPARAMS dispparams = {arg, NULL, ARRAY_SIZE(arg), 0};
2450 VARIANT out, in_ptr, in_out;
2451 HRESULT hr;
2452 BSTR bstr;
2453
2454 testmode = 0;
2455 V_VT(&out) = VT_I4;
2456 V_I4(&out) = 1;
2457 V_VT(&in_ptr) = VT_I4;
2458 V_I4(&in_ptr) = -1;
2459 V_VT(&in_out) = VT_BSTR;
2460 V_BSTR(&in_out) = bstr = SysAllocString(test_bstr2);
2461
2462 V_VT(&arg[3]) = VT_CY;
2463 V_CY(&arg[3]).Hi = 0xdababe;
2464 V_CY(&arg[3]).Lo = 0xdeadbeef;
2465 V_VT(&arg[2]) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&arg[2]) = &out;
2466 V_VT(&arg[1]) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&arg[1]) = &in_ptr;
2467 V_VT(&arg[0]) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&arg[0]) = &in_out;
2468 hr = IDispatch_Invoke(disp, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL,
2469 DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
2470 ok(hr == S_OK, "Got hr %#x.\n", hr);
2471 ok(V_VT(&arg[3]) == VT_CY, "Got wrong type %u.\n", V_VT(&arg[3]));
2472 ok(V_VT(&out) == VT_UI1, "Got wrong type %u.\n", V_VT(&out));
2473 ok(V_UI1(&out) == 3, "Got wrong value %d.\n", V_UI1(&out));
2474 VariantClear(&out);
2475 ok(V_VT(&in_ptr) == VT_I2, "Got wrong type %u.\n", V_VT(&in_ptr));
2476 ok(V_I2(&in_ptr) == 4, "Got wrong value %d.\n", V_I1(&in_ptr));
2477 ok(V_VT(&in_out) == VT_I1, "Got wrong type %u.\n", V_VT(&in_out));
2478 ok(V_I1(&in_out) == 5, "Got wrong value %d.\n", V_I1(&in_out));
2479
2480 testmode = 1;
2481 V_VT(&out) = VT_I4;
2482 V_I4(&out) = 1;
2483 V_VT(&in_ptr) = VT_I4;
2484 V_I4(&in_ptr) = -1;
2485 V_VT(&in_out) = VT_BSTR;
2486 V_BSTR(&in_out) = bstr = SysAllocString(test_bstr2);
2487 hr = IWidget_variant(widget, arg[3], &out, &in_ptr, &in_out);
2488 ok(hr == S_OK, "Got hr %#x.\n", hr);
2489 ok(V_VT(&arg[3]) == VT_CY, "Got wrong type %u.\n", V_VT(&arg[3]));
2490 ok(V_VT(&out) == VT_UI1, "Got wrong type %u.\n", V_VT(&out));
2491 ok(V_UI1(&out) == 3, "Got wrong value %d.\n", V_UI1(&out));
2492 ok(V_VT(&in_ptr) == VT_I4, "Got wrong type %u.\n", V_VT(&in_ptr));
2493 ok(V_I2(&in_ptr) == -1, "Got wrong value %d.\n", V_I1(&in_ptr));
2494 ok(V_VT(&in_out) == VT_I1, "Got wrong type %u.\n", V_VT(&in_out));
2495 ok(V_I1(&in_out) == 5, "Got wrong value %d.\n", V_I1(&in_out));
2496}
VT_CY
@ VT_CY
Definition: compat.h:2301
V_CY
#define V_CY(A)
Definition: oleauto.h:229
DISPID_TM_VARIANT
#define DISPID_TM_VARIANT
Definition: tmarshal_dispids.h:33

Referenced by test_typelibmarshal().

◆ test_StaticWidget()

static void test_StaticWidget ( void  )
static

Definition at line 3467 of file tmarshal.c.

3468{
3469 ITypeInfo *type_info;
3470 DISPPARAMS dispparams;
3471 VARIANTARG vararg[4];
3472 EXCEPINFO excepinfo;
3473 VARIANT varresult;
3474 HRESULT hr;
3475
3476 type_info = get_type_info(&IID_IStaticWidget);
3477
3478 /* call TestDual */
3479 dispparams.cNamedArgs = 0;
3480 dispparams.cArgs = 1;
3481 dispparams.rgdispidNamedArgs = NULL;
3482 dispparams.rgvarg = vararg;
3483 V_VT(vararg) = VT_DISPATCH;
3484 V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
3485 VariantInit(&varresult);
3486 hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
3487 &dispparams, &varresult, &excepinfo, NULL);
3488 ok_ole_success(hr, IDispatch_Invoke);
3489 ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
3490 VariantClear(&varresult);
3491
3492 /* call TestSecondIface */
3493 dispparams.cNamedArgs = 0;
3494 dispparams.cArgs = 1;
3495 dispparams.rgdispidNamedArgs = NULL;
3496 dispparams.rgvarg = vararg;
3497 V_VT(vararg) = VT_DISPATCH;
3498 V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
3499 VariantInit(&varresult);
3500 hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTSECONDIFACE, DISPATCH_METHOD,
3501 &dispparams, &varresult, &excepinfo, NULL);
3502 ok_ole_success(hr, IDispatch_Invoke);
3503 ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
3504 VariantClear(&varresult);
3505
3506 ITypeInfo_Release(type_info);
3507}
VT_EMPTY
@ VT_EMPTY
Definition: compat.h:2295
excepinfo
static EXCEPINFO excepinfo
Definition: automation.c:47
type_info
struct __type_info type_info
stdole::EXCEPINFO
struct stdole::EXCEPINFO EXCEPINFO
__type_info
Definition: cpp.c:33
StaticWidget
static IStaticWidget StaticWidget
Definition: tmarshal.c:1711
TestDualDisp
static ItestDual TestDualDisp
Definition: tmarshal.c:233
get_type_info
static ITypeInfo * get_type_info(REFIID riid)
Definition: tmarshal.c:1743
DISPID_TM_TESTSECONDIFACE
#define DISPID_TM_TESTSECONDIFACE
Definition: tmarshal_dispids.h:48
DISPID_TM_TESTDUAL
#define DISPID_TM_TESTDUAL
Definition: tmarshal_dispids.h:37

Referenced by START_TEST().

◆ test_typelibmarshal()

static void test_typelibmarshal ( void  )
static

Definition at line 2828 of file tmarshal.c.

2829{
2830 static const WCHAR szCat[] = { 'C','a','t',0 };
2831 static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
2832 static const WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
2833 HRESULT hr;
2834 IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
2835 IWidget *pWidget;
2836 IStream *pStream;
2837 IDispatch *pDispatch;
2838 static const LARGE_INTEGER ullZero;
2839 EXCEPINFO excepinfo;
2840 VARIANT varresult;
2841 DISPID dispidNamed = DISPID_PROPERTYPUT;
2842 DISPPARAMS dispparams;
2843 VARIANTARG vararg[4];
2844 STATE the_state;
2845 HANDLE thread;
2846 DWORD tid;
2847 BSTR bstr;
2848 ITypeInfo *pTypeInfo;
2849 UINT uval;
2850
2851 ok(pKEW != NULL, "Widget creation failed\n");
2852
2853 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2854 ok_ole_success(hr, CreateStreamOnHGlobal);
2855 tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
2856 IKindaEnumWidget_Release(pKEW);
2857
2858 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2859 hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
2860 ok_ole_success(hr, CoUnmarshalInterface);
2861 IStream_Release(pStream);
2862 if (FAILED(hr))
2863 {
2864 end_host_object(tid, thread);
2865 return;
2866 }
2867
2868 hr = IKindaEnumWidget_Next(pKEW, &pWidget);
2869 ok_ole_success(hr, IKindaEnumWidget_Next);
2870
2871 IKindaEnumWidget_Release(pKEW);
2872
2873 /* call GetTypeInfoCount (direct) */
2874 hr = IWidget_GetTypeInfoCount(pWidget, &uval);
2875 ok_ole_success(hr, IWidget_GetTypeInfoCount);
2876 hr = IWidget_GetTypeInfoCount(pWidget, &uval);
2877 ok_ole_success(hr, IWidget_GetTypeInfoCount);
2878
2879 hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
2880 ok_ole_success(hr, IWidget_QueryInterface);
2881
2882 /* call put_Name */
2883 VariantInit(&vararg[0]);
2884 dispparams.cNamedArgs = 1;
2885 dispparams.rgdispidNamedArgs = &dispidNamed;
2886 dispparams.cArgs = 1;
2887 dispparams.rgvarg = vararg;
2888 VariantInit(&varresult);
2889 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
2890 ok_ole_success(hr, IDispatch_Invoke);
2891 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
2892 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
2893 excepinfo.wCode, excepinfo.scode);
2894 VariantClear(&varresult);
2895
2896 /* call put_Name (direct) */
2897 bstr = SysAllocString(szSuperman);
2898 hr = IWidget_put_Name(pWidget, bstr);
2899 ok_ole_success(hr, IWidget_put_Name);
2900 SysFreeString(bstr);
2901
2902 /* call get_Name */
2903 dispparams.cNamedArgs = 0;
2904 dispparams.rgdispidNamedArgs = NULL;
2905 dispparams.cArgs = 0;
2906 dispparams.rgvarg = NULL;
2907 VariantInit(&varresult);
2908 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
2909 ok_ole_success(hr, IDispatch_Invoke);
2910 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
2911 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
2912 excepinfo.wCode, excepinfo.scode);
2913 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
2914 VariantClear(&varresult);
2915
2916 /* call get_Name (direct) */
2917 bstr = (void *)0xdeadbeef;
2918 hr = IWidget_get_Name(pWidget, &bstr);
2919 ok_ole_success(hr, IWidget_get_Name);
2920 ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
2921 SysFreeString(bstr);
2922
2923 /* call DoSomething without optional arguments */
2924 VariantInit(&vararg[0]);
2925 VariantInit(&vararg[1]);
2926 V_VT(&vararg[1]) = VT_R8;
2927 V_R8(&vararg[1]) = 3.141;
2928 dispparams.cNamedArgs = 0;
2929 dispparams.cArgs = 2;
2930 dispparams.rgdispidNamedArgs = NULL;
2931 dispparams.rgvarg = vararg;
2932 VariantInit(&varresult);
2933 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
2934 ok_ole_success(hr, IDispatch_Invoke);
2935 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
2936 VariantClear(&varresult);
2937
2938 /* call DoSomething with optional argument set to VT_EMPTY */
2939 VariantInit(&vararg[0]);
2940 VariantInit(&vararg[1]);
2941 VariantInit(&vararg[2]);
2942 V_VT(&vararg[2]) = VT_R8;
2943 V_R8(&vararg[2]) = 3.141;
2944 dispparams.cNamedArgs = 0;
2945 dispparams.cArgs = 3;
2946 dispparams.rgdispidNamedArgs = NULL;
2947 dispparams.rgvarg = vararg;
2948 VariantInit(&varresult);
2949 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
2950 ok_ole_success(hr, IDispatch_Invoke);
2951 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
2952 VariantClear(&varresult);
2953
2954 /* call DoSomething with optional arguments set to VT_ERROR/DISP_E_PARAMNOTFOUND */
2955 VariantInit(&vararg[0]);
2956 VariantInit(&vararg[1]);
2957 VariantInit(&vararg[2]);
2958 VariantInit(&vararg[3]);
2959 V_VT(&vararg[3]) = VT_R8;
2960 V_R8(&vararg[3]) = 3.141;
2961 V_VT(&vararg[1]) = VT_ERROR;
2962 V_ERROR(&vararg[1]) = DISP_E_PARAMNOTFOUND;
2963 V_VT(&vararg[0]) = VT_ERROR;
2964 V_ERROR(&vararg[0]) = DISP_E_PARAMNOTFOUND;
2965 dispparams.cNamedArgs = 0;
2966 dispparams.cArgs = 4;
2967 dispparams.rgdispidNamedArgs = NULL;
2968 dispparams.rgvarg = vararg;
2969 VariantInit(&varresult);
2970 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
2971 ok_ole_success(hr, IDispatch_Invoke);
2972 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
2973 VariantClear(&varresult);
2974
2975 /* call get_State */
2976 dispparams.cNamedArgs = 0;
2977 dispparams.cArgs = 0;
2978 dispparams.rgdispidNamedArgs = NULL;
2979 dispparams.rgvarg = NULL;
2980 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
2981 ok_ole_success(hr, IDispatch_Invoke);
2982 ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
2983
2984 /* call get_State (direct) */
2985 hr = IWidget_get_State(pWidget, &the_state);
2986 ok_ole_success(hr, IWidget_get_state);
2987 ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
2988
2989 /* call put_State */
2990 the_state = STATE_WIDGETIFIED;
2991 VariantInit(&vararg[0]);
2992 V_VT(&vararg[0]) = VT_BYREF|VT_I4;
2993 V_I4REF(&vararg[0]) = (int *)&the_state;
2994 dispparams.cNamedArgs = 1;
2995 dispparams.cArgs = 1;
2996 dispparams.rgdispidNamedArgs = &dispidNamed;
2997 dispparams.rgvarg = vararg;
2998 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
2999 ok_ole_success(hr, IDispatch_Invoke);
3000
3001 /* call Map */
3002 bstr = SysAllocString(szTestTest);
3003 VariantInit(&vararg[0]);
3004 V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
3005 V_BSTRREF(&vararg[0]) = &bstr;
3006 dispparams.cNamedArgs = 0;
3007 dispparams.cArgs = 1;
3008 dispparams.rgdispidNamedArgs = NULL;
3009 dispparams.rgvarg = vararg;
3010 VariantInit(&varresult);
3011 hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
3012 ok_ole_success(hr, IDispatch_Invoke);
3013 ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
3014 ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
3015 VariantClear(&varresult);
3016 SysFreeString(bstr);
3017
3018 /* call SetOleColor with large negative VT_I4 param */
3019 VariantInit(&vararg[0]);
3020 V_VT(&vararg[0]) = VT_I4;
3021 V_I4(&vararg[0]) = 0x80000005;
3022 dispparams.cNamedArgs = 0;
3023 dispparams.cArgs = 1;
3024 dispparams.rgdispidNamedArgs = NULL;
3025 dispparams.rgvarg = vararg;
3026 hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
3027 ok_ole_success(hr, IDispatch_Invoke);
3028
3029 /* call GetOleColor */
3030 dispparams.cNamedArgs = 0;
3031 dispparams.cArgs = 0;
3032 dispparams.rgdispidNamedArgs = NULL;
3033 dispparams.rgvarg = NULL;
3034 VariantInit(&varresult);
3035 hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
3036 ok_ole_success(hr, IDispatch_Invoke);
3037 VariantClear(&varresult);
3038
3039 /* call Clone */
3040 dispparams.cNamedArgs = 0;
3041 dispparams.cArgs = 0;
3042 dispparams.rgdispidNamedArgs = NULL;
3043 dispparams.rgvarg = NULL;
3044 VariantInit(&varresult);
3045 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
3046 ok_ole_success(hr, IDispatch_Invoke);
3047 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
3048 VariantClear(&varresult);
3049
3050 /* call CloneInterface */
3051 dispparams.cNamedArgs = 0;
3052 dispparams.cArgs = 0;
3053 dispparams.rgdispidNamedArgs = NULL;
3054 dispparams.rgvarg = NULL;
3055 VariantInit(&varresult);
3056 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
3057 ok_ole_success(hr, IDispatch_Invoke);
3058 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
3059 VariantClear(&varresult);
3060
3061 /* call CloneDispatch with automatic value getting */
3062 V_VT(&vararg[0]) = VT_I2;
3063 V_I2(&vararg[0]) = 1;
3064 dispparams.cNamedArgs = 0;
3065 dispparams.rgdispidNamedArgs = NULL;
3066 dispparams.cArgs = 1;
3067 dispparams.rgvarg = vararg;
3068 VariantInit(&varresult);
3069 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
3070 ok_ole_success(hr, IDispatch_Invoke);
3071
3072 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
3073 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
3074 excepinfo.wCode, excepinfo.scode);
3075
3076 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
3077 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
3078 VariantClear(&varresult);
3079
3080 /* call CloneCoclass */
3081 dispparams.cNamedArgs = 0;
3082 dispparams.cArgs = 0;
3083 dispparams.rgdispidNamedArgs = NULL;
3084 dispparams.rgvarg = NULL;
3085 VariantInit(&varresult);
3086 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
3087 ok_ole_success(hr, IDispatch_Invoke);
3088
3089 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
3090 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
3091 excepinfo.wCode, excepinfo.scode);
3092
3093 ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
3094 ok(V_DISPATCH(&varresult) != NULL, "expected V_DISPATCH(&varresult) != NULL\n");
3095
3096 /* call Value with a VT_VARIANT|VT_BYREF type */
3097 V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
3098 V_VARIANTREF(&vararg[0]) = &vararg[1];
3099 V_VT(&vararg[1]) = VT_I2;
3100 V_I2(&vararg[1]) = 1;
3101 dispparams.cNamedArgs = 0;
3102 dispparams.rgdispidNamedArgs = NULL;
3103 dispparams.cArgs = 1;
3104 dispparams.rgvarg = vararg;
3105 VariantInit(&varresult);
3106 hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
3107 ok_ole_success(hr, IDispatch_Invoke);
3108
3109 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
3110 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
3111 excepinfo.wCode, excepinfo.scode);
3112
3113 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
3114 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
3115 VariantClear(&varresult);
3116
3117 /* call Array with BSTR argument - type mismatch */
3118 VariantInit(&vararg[0]);
3119 V_VT(&vararg[0]) = VT_BSTR;
3120 V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
3121 dispparams.cNamedArgs = 0;
3122 dispparams.cArgs = 1;
3123 dispparams.rgdispidNamedArgs = NULL;
3124 dispparams.rgvarg = vararg;
3125 hr = IDispatch_Invoke(pDispatch, DISPID_TM_ARRAY, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
3126 ok(hr == DISP_E_TYPEMISMATCH || hr == DISP_E_BADVARTYPE, "expected DISP_E_TYPEMISMATCH, got %#x\n", hr);
3127 SysFreeString(V_BSTR(&vararg[0]));
3128
3129 /* call ArrayPtr with BSTR argument - type mismatch */
3130 VariantInit(&vararg[0]);
3131 V_VT(&vararg[0]) = VT_BSTR;
3132 V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
3133 dispparams.cNamedArgs = 0;
3134 dispparams.cArgs = 1;
3135 dispparams.rgdispidNamedArgs = NULL;
3136 dispparams.rgvarg = vararg;
3137 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARRAYPTR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
3138 ok(hr == DISP_E_TYPEMISMATCH || hr == DISP_E_BADVARTYPE, "expected DISP_E_TYPEMISMATCH, got %#x\n", hr);
3139 SysFreeString(V_BSTR(&vararg[0]));
3140
3141 /* call VarArg */
3142 VariantInit(&vararg[3]);
3143 V_VT(&vararg[3]) = VT_I4;
3144 V_I4(&vararg[3]) = 3;
3145 VariantInit(&vararg[2]);
3146 V_VT(&vararg[2]) = VT_I4;
3147 V_I4(&vararg[2]) = 0;
3148 VariantInit(&vararg[1]);
3149 V_VT(&vararg[1]) = VT_I4;
3150 V_I4(&vararg[1]) = 1;
3151 VariantInit(&vararg[0]);
3152 V_VT(&vararg[0]) = VT_I4;
3153 V_I4(&vararg[0]) = 2;
3154 dispparams.cNamedArgs = 0;
3155 dispparams.cArgs = 4;
3156 dispparams.rgdispidNamedArgs = NULL;
3157 dispparams.rgvarg = vararg;
3158 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
3159 ok_ole_success(hr, IDispatch_Invoke);
3160
3161 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
3162 dispidNamed = 0;
3163 dispparams.cNamedArgs = 1;
3164 dispparams.rgdispidNamedArgs = &dispidNamed;
3165 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
3166 ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
3167 dispidNamed = DISPID_PROPERTYPUT;
3168
3169 /* call VarArg_Run */
3170 VariantInit(&vararg[1]);
3171 V_VT(&vararg[1]) = VT_BSTR;
3172 V_BSTR(&vararg[1]) = SysAllocString(szCat);
3173 VariantInit(&vararg[0]);
3174 V_VT(&vararg[0]) = VT_BSTR;
3175 V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
3176 dispparams.cNamedArgs = 0;
3177 dispparams.cArgs = 2;
3178 dispparams.rgdispidNamedArgs = NULL;
3179 dispparams.rgvarg = vararg;
3180 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
3181 ok_ole_success(hr, IDispatch_Invoke);
3182 SysFreeString(V_BSTR(&vararg[1]));
3183 SysFreeString(V_BSTR(&vararg[0]));
3184
3185 /* call VarArg_Ref_Run */
3186 VariantInit(&vararg[1]);
3187 V_VT(&vararg[1]) = VT_BSTR;
3188 V_BSTR(&vararg[1]) = SysAllocString(szCat);
3189 VariantInit(&vararg[0]);
3190 V_VT(&vararg[0]) = VT_BSTR;
3191 V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
3192 dispparams.cNamedArgs = 0;
3193 dispparams.cArgs = 2;
3194 dispparams.rgdispidNamedArgs = NULL;
3195 dispparams.rgvarg = vararg;
3196 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_REF_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
3197 ok_ole_success(hr, IDispatch_Invoke);
3198 SysFreeString(V_BSTR(&vararg[1]));
3199 SysFreeString(V_BSTR(&vararg[0]));
3200
3201 /* call Error */
3202 dispparams.cNamedArgs = 0;
3203 dispparams.cArgs = 0;
3204 dispparams.rgdispidNamedArgs = NULL;
3205 dispparams.rgvarg = NULL;
3206 VariantInit(&varresult);
3207 hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
3208 ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
3209 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
3210 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
3211 excepinfo.wCode, excepinfo.scode);
3212 VariantClear(&varresult);
3213
3214 /* call BstrRet */
3215 pTypeInfo = NonOleAutomation_GetTypeInfo();
3216 dispparams.cNamedArgs = 0;
3217 dispparams.cArgs = 0;
3218 dispparams.rgdispidNamedArgs = NULL;
3219 dispparams.rgvarg = NULL;
3220 VariantInit(&varresult);
3221 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
3222 ok_ole_success(hr, ITypeInfo_Invoke);
3223 ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
3224 ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
3225
3226 VariantClear(&varresult);
3227
3228 dispparams.cNamedArgs = 0;
3229 dispparams.cArgs = 0;
3230 dispparams.rgdispidNamedArgs = NULL;
3231 dispparams.rgvarg = NULL;
3232 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_ERROR, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
3233 ok(hr == DISP_E_EXCEPTION, "ITypeInfo_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
3234 ok(V_VT(&varresult) == VT_EMPTY, "V_VT(&varresult) should be VT_EMPTY instead of %d\n", V_VT(&varresult));
3235 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
3236 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
3237 excepinfo.wCode, excepinfo.scode);
3238 VariantClear(&varresult);
3239
3240 ITypeInfo_Release(pTypeInfo);
3241
3242 /* tests call put_Name without named arg */
3243 VariantInit(&vararg[0]);
3244 dispparams.cNamedArgs = 0;
3245 dispparams.rgdispidNamedArgs = NULL;
3246 dispparams.cArgs = 1;
3247 dispparams.rgvarg = vararg;
3248 VariantInit(&varresult);
3249 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
3250 ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
3251 VariantClear(&varresult);
3252
3253 /* tests param type that cannot be coerced */
3254 VariantInit(&vararg[0]);
3255 V_VT(&vararg[0]) = VT_UNKNOWN;
3256 V_UNKNOWN(&vararg[0]) = NULL;
3257 dispparams.cNamedArgs = 1;
3258 dispparams.rgdispidNamedArgs = &dispidNamed;
3259 dispparams.cArgs = 1;
3260 dispparams.rgvarg = vararg;
3261 VariantInit(&varresult);
3262 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
3263 ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
3264 VariantClear(&varresult);
3265
3266 /* tests bad param type */
3267 VariantInit(&vararg[0]);
3268 V_VT(&vararg[0]) = VT_CLSID;
3269 V_BYREF(&vararg[0]) = NULL;
3270 dispparams.cNamedArgs = 1;
3271 dispparams.rgdispidNamedArgs = &dispidNamed;
3272 dispparams.cArgs = 1;
3273 dispparams.rgvarg = vararg;
3274 VariantInit(&varresult);
3275 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
3276 ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
3277 VariantClear(&varresult);
3278
3279 /* tests too small param count */
3280 dispparams.cNamedArgs = 0;
3281 dispparams.rgdispidNamedArgs = NULL;
3282 dispparams.cArgs = 0;
3283 dispparams.rgvarg = NULL;
3284 VariantInit(&varresult);
3285 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
3286 ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
3287 VariantClear(&varresult);
3288
3289 /* tests propget function with large param count */
3290 VariantInit(&vararg[0]);
3291 V_VT(&vararg[0]) = VT_BSTR;
3292 V_BSTR(&vararg[0]) = NULL;
3293 V_VT(&vararg[1]) = VT_I4;
3294 V_I4(&vararg[1]) = 1;
3295 dispparams.cNamedArgs = 0;
3296 dispparams.cArgs = 2;
3297 dispparams.rgdispidNamedArgs = NULL;
3298 dispparams.rgvarg = vararg;
3299 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
3300 ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
3301
3302 /* test propput with lcid */
3303
3304 /* the lcid passed to the function is the first lcid in the typelib header.
3305 Since we don't explicitly set an lcid in the idl, it'll default to US English. */
3306 VariantInit(&vararg[0]);
3307