2 * Copyright (C) 2005-2006 Robert Shearman for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wine/test.h"
30 #include "tmarshal_dispids.h"
32 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", (unsigned long int)hr)
34 /* ULL suffix is not portable */
35 #define ULL_CONST(dw1, dw2) ((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)
37 const MYSTRUCT MYSTRUCT_BYVAL
= {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432)};
38 const MYSTRUCT MYSTRUCT_BYPTR
= {0x91827364, ULL_CONST(0x88776655, 0x44332211)};
39 const MYSTRUCT MYSTRUCT_ARRAY
[5] = {
40 {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415)},
41 {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425)},
42 {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435)},
43 {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445)},
44 {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455)},
48 #define RELEASEMARSHALDATA WM_USER
50 struct host_object_data
55 MSHLFLAGS marshal_flags
;
57 IMessageFilter
*filter
;
60 static DWORD CALLBACK
host_object_proc(LPVOID p
)
62 struct host_object_data
*data
= p
;
66 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
70 IMessageFilter
* prev_filter
= NULL
;
71 hr
= CoRegisterMessageFilter(data
->filter
, &prev_filter
);
72 if (prev_filter
) IMessageFilter_Release(prev_filter
);
73 ok_ole_success(hr
, CoRegisterMessageFilter
);
76 hr
= CoMarshalInterface(data
->stream
, &data
->iid
, data
->object
, MSHCTX_INPROC
, NULL
, data
->marshal_flags
);
77 ok_ole_success(hr
, CoMarshalInterface
);
79 /* force the message queue to be created before signaling parent thread */
80 PeekMessage(&msg
, NULL
, WM_USER
, WM_USER
, PM_NOREMOVE
);
82 SetEvent(data
->marshal_event
);
84 while (GetMessage(&msg
, NULL
, 0, 0))
86 if (msg
.hwnd
== NULL
&& msg
.message
== RELEASEMARSHALDATA
)
88 trace("releasing marshal data\n");
89 CoReleaseMarshalData(data
->stream
);
90 SetEvent((HANDLE
)msg
.lParam
);
93 DispatchMessage(&msg
);
96 HeapFree(GetProcessHeap(), 0, data
);
103 static DWORD
start_host_object2(IStream
*stream
, REFIID riid
, IUnknown
*object
, MSHLFLAGS marshal_flags
, IMessageFilter
*filter
, HANDLE
*thread
)
106 HANDLE marshal_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
107 struct host_object_data
*data
= HeapAlloc(GetProcessHeap(), 0, sizeof(*data
));
109 data
->stream
= stream
;
111 data
->object
= object
;
112 data
->marshal_flags
= marshal_flags
;
113 data
->marshal_event
= marshal_event
;
114 data
->filter
= filter
;
116 *thread
= CreateThread(NULL
, 0, host_object_proc
, data
, 0, &tid
);
118 /* wait for marshaling to complete before returning */
119 WaitForSingleObject(marshal_event
, INFINITE
);
120 CloseHandle(marshal_event
);
125 static DWORD
start_host_object(IStream
*stream
, REFIID riid
, IUnknown
*object
, MSHLFLAGS marshal_flags
, HANDLE
*thread
)
127 return start_host_object2(stream
, riid
, object
, marshal_flags
, NULL
, thread
);
131 /* asks thread to release the marshal data because it has to be done by the
132 * same thread that marshaled the interface in the first place. */
133 static void release_host_object(DWORD tid
)
135 HANDLE event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
136 PostThreadMessage(tid
, RELEASEMARSHALDATA
, 0, (LPARAM
)event
);
137 WaitForSingleObject(event
, INFINITE
);
142 static void end_host_object(DWORD tid
, HANDLE thread
)
144 BOOL ret
= PostThreadMessage(tid
, WM_QUIT
, 0, 0);
145 ok(ret
, "PostThreadMessage failed with error %d\n", GetLastError());
146 /* be careful of races - don't return until hosting thread has terminated */
147 WaitForSingleObject(thread
, INFINITE
);
151 static ItestDual TestDual
, TestDualDisp
;
153 static HRESULT WINAPI
TestDual_QueryInterface(ItestDual
*iface
, REFIID riid
, void **ppvObject
)
155 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
)) {
156 *ppvObject
= &TestDualDisp
;
158 }else if(IsEqualGUID(riid
, &IID_ItestDual
)) {
159 *ppvObject
= &TestDual
;
164 return E_NOINTERFACE
;
167 static ULONG WINAPI
TestDual_AddRef(ItestDual
*iface
)
172 static ULONG WINAPI
TestDual_Release(ItestDual
*iface
)
177 static HRESULT WINAPI
TestDual_GetTypeInfoCount(ItestDual
*iface
, UINT
*pctinfo
)
179 ok(0, "unexpected call\n");
183 static HRESULT WINAPI
TestDual_GetTypeInfo(ItestDual
*iface
, UINT iTInfo
, LCID lcid
, ITypeInfo
**ppTInfo
)
185 ok(0, "unexpected call\n");
189 static HRESULT WINAPI
TestDual_GetIDsOfNames(ItestDual
*iface
, REFIID riid
, LPOLESTR
*rgszNames
,
190 UINT cNames
, LCID lcid
, DISPID
*rgDispId
)
192 ok(0, "unexpected call\n");
196 static HRESULT WINAPI
TestDual_Invoke(ItestDual
*iface
, DISPID dispIdMember
, REFIID riid
, LCID lcid
,
197 WORD wFlags
, DISPPARAMS
*pDispParams
, VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
,
200 ok(0, "unexpected call\n");
204 static ItestDualVtbl TestDualVtbl
= {
205 TestDual_QueryInterface
,
208 TestDual_GetTypeInfoCount
,
209 TestDual_GetTypeInfo
,
210 TestDual_GetIDsOfNames
,
214 static ItestDual TestDual
= { &TestDualVtbl
};
215 static ItestDual TestDualDisp
= { &TestDualVtbl
};
217 typedef struct Widget
219 const IWidgetVtbl
*lpVtbl
;
221 IUnknown
*pDispatchUnknown
;
224 static HRESULT WINAPI
Widget_QueryInterface(
226 /* [in] */ REFIID riid
,
227 /* [iid_is][out] */ void __RPC_FAR
*__RPC_FAR
*ppvObject
)
229 if (IsEqualIID(riid
, &IID_IWidget
) || IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
))
231 IWidget_AddRef(iface
);
238 return E_NOINTERFACE
;
242 static ULONG WINAPI
Widget_AddRef(
245 Widget
*This
= (Widget
*)iface
;
247 return InterlockedIncrement(&This
->refs
);
250 static ULONG WINAPI
Widget_Release(
253 Widget
*This
= (Widget
*)iface
;
254 ULONG refs
= InterlockedDecrement(&This
->refs
);
257 IUnknown_Release(This
->pDispatchUnknown
);
258 memset(This
, 0xcc, sizeof(*This
));
259 HeapFree(GetProcessHeap(), 0, This
);
260 trace("Widget destroyed!\n");
266 static HRESULT WINAPI
Widget_GetTypeInfoCount(
268 /* [out] */ UINT __RPC_FAR
*pctinfo
)
270 Widget
*This
= (Widget
*)iface
;
271 IDispatch
*pDispatch
;
272 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
275 hr
= IDispatch_GetTypeInfoCount(pDispatch
, pctinfo
);
276 IDispatch_Release(pDispatch
);
281 static HRESULT WINAPI
Widget_GetTypeInfo(
282 IWidget __RPC_FAR
* iface
,
283 /* [in] */ UINT iTInfo
,
284 /* [in] */ LCID lcid
,
285 /* [out] */ ITypeInfo __RPC_FAR
*__RPC_FAR
*ppTInfo
)
287 Widget
*This
= (Widget
*)iface
;
288 IDispatch
*pDispatch
;
289 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
292 hr
= IDispatch_GetTypeInfo(pDispatch
, iTInfo
, lcid
, ppTInfo
);
293 IDispatch_Release(pDispatch
);
298 static HRESULT WINAPI
Widget_GetIDsOfNames(
299 IWidget __RPC_FAR
* iface
,
300 /* [in] */ REFIID riid
,
301 /* [size_is][in] */ LPOLESTR __RPC_FAR
*rgszNames
,
302 /* [in] */ UINT cNames
,
303 /* [in] */ LCID lcid
,
304 /* [size_is][out] */ DISPID __RPC_FAR
*rgDispId
)
306 Widget
*This
= (Widget
*)iface
;
307 IDispatch
*pDispatch
;
308 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
311 hr
= IDispatch_GetIDsOfNames(pDispatch
, riid
, rgszNames
, cNames
, lcid
, rgDispId
);
312 IDispatch_Release(pDispatch
);
317 static HRESULT WINAPI
Widget_Invoke(
318 IWidget __RPC_FAR
* iface
,
319 /* [in] */ DISPID dispIdMember
,
320 /* [in] */ REFIID riid
,
321 /* [in] */ LCID lcid
,
322 /* [in] */ WORD wFlags
,
323 /* [out][in] */ DISPPARAMS __RPC_FAR
*pDispParams
,
324 /* [out] */ VARIANT __RPC_FAR
*pVarResult
,
325 /* [out] */ EXCEPINFO __RPC_FAR
*pExcepInfo
,
326 /* [out] */ UINT __RPC_FAR
*puArgErr
)
328 Widget
*This
= (Widget
*)iface
;
329 IDispatch
*pDispatch
;
330 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
333 hr
= IDispatch_Invoke(pDispatch
, dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
334 IDispatch_Release(pDispatch
);
339 static HRESULT WINAPI
Widget_put_Name(
340 IWidget __RPC_FAR
* iface
,
341 /* [in] */ BSTR name
)
343 trace("put_Name(%s)\n", wine_dbgstr_w(name
));
347 static HRESULT WINAPI
Widget_get_Name(
348 IWidget __RPC_FAR
* iface
,
349 /* [out] */ BSTR __RPC_FAR
*name
)
351 static const WCHAR szCat
[] = { 'C','a','t',0 };
352 trace("get_Name()\n");
353 *name
= SysAllocString(szCat
);
357 static HRESULT WINAPI
Widget_DoSomething(
358 IWidget __RPC_FAR
* iface
,
359 /* [in] */ double number
,
360 /* [out] */ BSTR
*str1
,
361 /* [defaultvalue][in] */ BSTR str2
,
362 /* [optional][in] */ VARIANT __RPC_FAR
*opt
)
364 static const WCHAR szString
[] = { 'S','t','r','i','n','g',0 };
365 trace("DoSomething()\n");
367 ok(number
== 3.141, "number(%f) != 3.141\n", number
);
368 ok(*str2
== '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2
));
369 ok(V_VT(opt
) == VT_ERROR
, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt
));
370 ok(V_ERROR(opt
) == DISP_E_PARAMNOTFOUND
, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt
));
371 *str1
= SysAllocString(szString
);
376 static HRESULT WINAPI
Widget_get_State(
377 IWidget __RPC_FAR
* iface
,
378 /* [retval][out] */ STATE __RPC_FAR
*state
)
380 trace("get_State() = STATE_WIDGETIFIED\n");
381 *state
= STATE_WIDGETIFIED
;
385 static HRESULT WINAPI
Widget_put_State(
386 IWidget __RPC_FAR
* iface
,
387 /* [in] */ STATE state
)
389 trace("put_State(%d)\n", state
);
393 static HRESULT WINAPI
Widget_Map(
398 trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId
), sValue
);
399 *sValue
= SysAllocString(bstrId
);
403 static HRESULT WINAPI
Widget_SetOleColor(
407 trace("SetOleColor(0x%x)\n", val
);
411 static HRESULT WINAPI
Widget_GetOleColor(
415 trace("GetOleColor() = 0x8000000f\n");
420 static HRESULT WINAPI
Widget_Clone(
425 return Widget_QueryInterface(iface
, &IID_IWidget
, (void **)ppVal
);
428 static HRESULT WINAPI
Widget_CloneDispatch(
432 trace("CloneDispatch()\n");
433 return Widget_QueryInterface(iface
, &IID_IWidget
, (void **)ppVal
);
436 static HRESULT WINAPI
Widget_CloneCoclass(
438 ApplicationObject2
**ppVal
)
440 trace("CloneCoclass()\n");
444 static HRESULT WINAPI
Widget_Value(
445 IWidget __RPC_FAR
* iface
,
449 trace("Value(%p, %p)\n", value
, retval
);
450 ok(V_VT(value
) == VT_I2
, "V_VT(value) was %d instead of VT_I2\n", V_VT(value
));
451 ok(V_I2(value
) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value
));
452 V_VT(retval
) = VT_I2
;
457 static HRESULT WINAPI
Widget_Array(
461 trace("Array(%p)\n", values
);
465 static HRESULT WINAPI
Widget_VariantArrayPtr(
469 trace("VariantArrayPtr(%p)\n", values
);
473 static HRESULT WINAPI
Widget_Variant(
474 IWidget __RPC_FAR
* iface
,
477 trace("Variant()\n");
478 ok(V_VT(&var
) == VT_CY
, "V_VT(&var) was %d\n", V_VT(&var
));
479 ok(S(V_CY(&var
)).Hi
== 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var
)).Hi
);
480 ok(S(V_CY(&var
)).Lo
== 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var
)).Lo
);
484 static HRESULT WINAPI
Widget_VarArg(
489 LONG lbound
, ubound
, i
;
493 trace("VarArg(%p)\n", values
);
495 hr
= SafeArrayGetLBound(values
, 1, &lbound
);
496 ok(hr
== S_OK
, "SafeArrayGetLBound failed with %x\n", hr
);
497 ok(lbound
== 0, "SafeArrayGetLBound returned %d\n", lbound
);
499 hr
= SafeArrayGetUBound(values
, 1, &ubound
);
500 ok(hr
== S_OK
, "SafeArrayGetUBound failed with %x\n", hr
);
501 ok(ubound
== numexpect
-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound
, numexpect
-1);
503 hr
= SafeArrayAccessData(values
, (LPVOID
)&data
);
504 ok(hr
== S_OK
, "SafeArrayAccessData failed with %x\n", hr
);
506 for (i
=0; i
<=ubound
-lbound
; i
++)
508 ok(V_VT(&data
[i
]) == VT_I4
, "V_VT(&data[%d]) was %d\n", i
, V_VT(&data
[i
]));
509 ok(V_I4(&data
[i
]) == i
, "V_I4(&data[%d]) was %d\n", i
, V_I4(&data
[i
]));
512 hr
= SafeArrayUnaccessData(values
);
513 ok(hr
== S_OK
, "SafeArrayUnaccessData failed with %x\n", hr
);
518 static HRESULT WINAPI
Widget_StructArgs(
525 ok(byval
.field1
== MYSTRUCT_BYVAL
.field1
&&
526 byval
.field2
== MYSTRUCT_BYVAL
.field2
,
527 "Struct parameter passed by value corrupted\n");
528 ok(byptr
->field1
== MYSTRUCT_BYPTR
.field1
&&
529 byptr
->field2
== MYSTRUCT_BYPTR
.field2
,
530 "Struct parameter passed by pointer corrupted\n");
531 for (i
= 0; i
< 5; i
++)
532 if (arr
[i
].field1
!= MYSTRUCT_ARRAY
[i
].field1
||
533 arr
[i
].field2
!= MYSTRUCT_ARRAY
[i
].field2
)
535 ok(diff
== 0, "Array of structs corrupted\n");
540 static HRESULT WINAPI
Widget_Error(
541 IWidget __RPC_FAR
* iface
)
547 static HRESULT WINAPI
Widget_CloneInterface(
548 IWidget __RPC_FAR
* iface
,
549 ISomethingFromDispatch
**ppVal
)
551 trace("CloneInterface()\n");
556 static HRESULT WINAPI
Widget_put_prop_with_lcid(
557 IWidget
* iface
, LONG lcid
, INT i
)
559 trace("put_prop_with_lcid(%08x, %x)\n", lcid
, i
);
560 ok(lcid
== MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), "got lcid %08x\n", lcid
);
561 ok(i
== 0xcafe, "got %08x\n", i
);
565 static HRESULT WINAPI
Widget_get_prop_with_lcid(
566 IWidget
* iface
, LONG lcid
, INT
*i
)
568 trace("get_prop_with_lcid(%08x, %p)\n", lcid
, i
);
569 ok(lcid
== MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), "got lcid %08x\n", lcid
);
574 static HRESULT WINAPI
Widget_get_prop_int(
575 IWidget
* iface
, INT
*i
)
577 trace("get_prop_int(%p)\n", i
);
582 static HRESULT WINAPI
Widget_get_prop_uint(
583 IWidget
* iface
, UINT
*i
)
585 trace("get_prop_uint(%p)\n", i
);
590 static const struct IWidgetVtbl Widget_VTable
=
592 Widget_QueryInterface
,
595 Widget_GetTypeInfoCount
,
597 Widget_GetIDsOfNames
,
608 Widget_CloneDispatch
,
612 Widget_VariantArrayPtr
,
617 Widget_CloneInterface
,
618 Widget_put_prop_with_lcid
,
619 Widget_get_prop_with_lcid
,
624 static HRESULT WINAPI
StaticWidget_QueryInterface(IStaticWidget
*iface
, REFIID riid
, void **ppvObject
)
626 if (IsEqualIID(riid
, &IID_IStaticWidget
) || IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
))
628 IStaticWidget_AddRef(iface
);
634 return E_NOINTERFACE
;
637 static ULONG WINAPI
StaticWidget_AddRef(IStaticWidget
*iface
)
642 static ULONG WINAPI
StaticWidget_Release(IStaticWidget
*iface
)
647 static HRESULT WINAPI
StaticWidget_GetTypeInfoCount(IStaticWidget
*iface
, UINT
*pctinfo
)
649 ok(0, "unexpected call\n");
653 static HRESULT WINAPI
StaticWidget_GetTypeInfo(IStaticWidget
*iface
, UINT iTInfo
, LCID lcid
,
656 ok(0, "unexpected call\n");
660 static HRESULT WINAPI
StaticWidget_GetIDsOfNames(IStaticWidget
*iface
, REFIID riid
, LPOLESTR
*rgszNames
,
661 UINT cNames
, LCID lcid
, DISPID
*rgDispId
)
663 ok(0, "unexpected call\n");
667 static HRESULT WINAPI
StaticWidget_Invoke(IStaticWidget
*iface
, DISPID dispIdMember
, REFIID riid
,
668 LCID lcid
, WORD wFlags
, DISPPARAMS
*pDispParams
, VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
,
671 ok(0, "unexpected call\n");
675 static HRESULT WINAPI
StaticWidget_TestDual(IStaticWidget
*iface
, ItestDual
*p
)
677 trace("TestDual()\n");
679 ok(p
== &TestDual
, "wrong ItestDual\n");
683 static const IStaticWidgetVtbl StaticWidgetVtbl
= {
684 StaticWidget_QueryInterface
,
686 StaticWidget_Release
,
687 StaticWidget_GetTypeInfoCount
,
688 StaticWidget_GetTypeInfo
,
689 StaticWidget_GetIDsOfNames
,
691 StaticWidget_TestDual
694 static IStaticWidget StaticWidget
= { &StaticWidgetVtbl
};
696 typedef struct KindaEnum
698 const IKindaEnumWidgetVtbl
*lpVtbl
;
702 static HRESULT
register_current_module_typelib(void)
704 WCHAR path
[MAX_PATH
];
705 CHAR pathA
[MAX_PATH
];
709 GetModuleFileNameA(NULL
, pathA
, MAX_PATH
);
710 MultiByteToWideChar(CP_ACP
, 0, pathA
, -1, path
, MAX_PATH
);
712 hr
= LoadTypeLib(path
, &typelib
);
715 hr
= RegisterTypeLib(typelib
, path
, NULL
);
716 ITypeLib_Release(typelib
);
721 static ITypeInfo
*get_type_info(REFIID riid
)
723 ITypeInfo
*pTypeInfo
;
727 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
728 ok_ole_success(hr
, LoadRegTypeLib
);
732 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, riid
, &pTypeInfo
);
733 ITypeLib_Release(pTypeLib
);
734 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
741 static IWidget
*Widget_Create(void)
744 ITypeInfo
*pTypeInfo
;
747 pTypeInfo
= get_type_info(&IID_IWidget
);
751 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
752 This
->lpVtbl
= &Widget_VTable
;
754 This
->pDispatchUnknown
= NULL
;
756 hr
= CreateStdDispatch((IUnknown
*)&This
->lpVtbl
, This
, pTypeInfo
, &This
->pDispatchUnknown
);
757 ok_ole_success(hr
, CreateStdDispatch
);
758 ITypeInfo_Release(pTypeInfo
);
761 return (IWidget
*)&This
->lpVtbl
;
764 HeapFree(GetProcessHeap(), 0, This
);
769 static HRESULT WINAPI
KindaEnum_QueryInterface(
770 IKindaEnumWidget
*iface
,
771 /* [in] */ REFIID riid
,
772 /* [iid_is][out] */ void __RPC_FAR
*__RPC_FAR
*ppvObject
)
774 if (IsEqualIID(riid
, &IID_IKindaEnumWidget
) || IsEqualIID(riid
, &IID_IUnknown
))
776 IKindaEnumWidget_AddRef(iface
);
783 return E_NOINTERFACE
;
787 static ULONG WINAPI
KindaEnum_AddRef(
788 IKindaEnumWidget
*iface
)
790 KindaEnum
*This
= (KindaEnum
*)iface
;
792 return InterlockedIncrement(&This
->refs
);
795 static ULONG WINAPI
KindaEnum_Release(
796 IKindaEnumWidget
*iface
)
798 KindaEnum
*This
= (KindaEnum
*)iface
;
799 ULONG refs
= InterlockedDecrement(&This
->refs
);
802 memset(This
, 0xcc, sizeof(*This
));
803 HeapFree(GetProcessHeap(), 0, This
);
804 trace("KindaEnumWidget destroyed!\n");
810 static HRESULT WINAPI
KindaEnum_Next(
811 IKindaEnumWidget
*iface
,
812 /* [out] */ IWidget __RPC_FAR
*__RPC_FAR
*widget
)
814 *widget
= Widget_Create();
818 return E_OUTOFMEMORY
;
821 static HRESULT WINAPI
KindaEnum_Count(
822 IKindaEnumWidget
*iface
,
823 /* [out] */ ULONG __RPC_FAR
*count
)
828 static HRESULT WINAPI
KindaEnum_Reset(
829 IKindaEnumWidget
*iface
)
834 static HRESULT WINAPI
KindaEnum_Clone(
835 IKindaEnumWidget
*iface
,
836 /* [out] */ IKindaEnumWidget __RPC_FAR
*__RPC_FAR
*ppenum
)
841 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable
=
843 KindaEnum_QueryInterface
,
852 static IKindaEnumWidget
*KindaEnumWidget_Create(void)
856 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
857 if (!This
) return NULL
;
858 This
->lpVtbl
= &KindaEnumWidget_VTable
;
860 return (IKindaEnumWidget
*)This
;
863 static HRESULT WINAPI
NonOleAutomation_QueryInterface(INonOleAutomation
*iface
, REFIID riid
, void **ppv
)
865 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_INonOleAutomation
))
867 *(INonOleAutomation
**)ppv
= iface
;
871 return E_NOINTERFACE
;
874 static ULONG WINAPI
NonOleAutomation_AddRef(INonOleAutomation
*iface
)
879 static ULONG WINAPI
NonOleAutomation_Release(INonOleAutomation
*iface
)
884 static BSTR WINAPI
NonOleAutomation_BstrRet(INonOleAutomation
*iface
)
886 static const WCHAR wszTestString
[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
887 return SysAllocString(wszTestString
);
890 static INonOleAutomationVtbl NonOleAutomation_VTable
=
892 NonOleAutomation_QueryInterface
,
893 NonOleAutomation_AddRef
,
894 NonOleAutomation_Release
,
895 NonOleAutomation_BstrRet
,
898 static INonOleAutomation NonOleAutomation
= { &NonOleAutomation_VTable
};
900 static ITypeInfo
*NonOleAutomation_GetTypeInfo(void)
903 HRESULT hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
904 ok_ole_success(hr
, LoadRegTypeLib
);
907 ITypeInfo
*pTypeInfo
;
908 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_INonOleAutomation
, &pTypeInfo
);
909 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
915 static void test_typelibmarshal(void)
917 static const WCHAR szCat
[] = { 'C','a','t',0 };
918 static const WCHAR szTestTest
[] = { 'T','e','s','t','T','e','s','t',0 };
919 static WCHAR szSuperman
[] = { 'S','u','p','e','r','m','a','n',0 };
921 IKindaEnumWidget
*pKEW
= KindaEnumWidget_Create();
924 IDispatch
*pDispatch
;
925 static const LARGE_INTEGER ullZero
;
928 DISPID dispidNamed
= DISPID_PROPERTYPUT
;
929 DISPPARAMS dispparams
;
930 VARIANTARG vararg
[4];
935 ITypeInfo
*pTypeInfo
;
937 MYSTRUCT mystructArray
[5];
939 ok(pKEW
!= NULL
, "Widget creation failed\n");
941 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
942 ok_ole_success(hr
, CreateStreamOnHGlobal
);
943 tid
= start_host_object(pStream
, &IID_IKindaEnumWidget
, (IUnknown
*)pKEW
, MSHLFLAGS_NORMAL
, &thread
);
944 IKindaEnumWidget_Release(pKEW
);
946 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
947 hr
= CoUnmarshalInterface(pStream
, &IID_IKindaEnumWidget
, (void **)&pKEW
);
948 ok_ole_success(hr
, CoUnmarshalInterface
);
949 IStream_Release(pStream
);
951 hr
= IKindaEnumWidget_Next(pKEW
, &pWidget
);
952 ok_ole_success(hr
, IKindaEnumWidget_Next
);
954 IKindaEnumWidget_Release(pKEW
);
956 hr
= IWidget_QueryInterface(pWidget
, &IID_IDispatch
, (void **)&pDispatch
);
959 VariantInit(&vararg
[0]);
960 dispparams
.cNamedArgs
= 1;
961 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
962 dispparams
.cArgs
= 1;
963 dispparams
.rgvarg
= vararg
;
964 VariantInit(&varresult
);
965 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
966 ok_ole_success(hr
, IDispatch_Invoke
);
967 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
968 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
969 excepinfo
.wCode
, excepinfo
.scode
);
970 VariantClear(&varresult
);
972 /* call put_Name (direct) */
973 bstr
= SysAllocString(szSuperman
);
974 hr
= IWidget_put_Name(pWidget
, bstr
);
975 ok_ole_success(hr
, IWidget_put_Name
);
979 dispparams
.cNamedArgs
= 0;
980 dispparams
.rgdispidNamedArgs
= NULL
;
981 dispparams
.cArgs
= 0;
982 dispparams
.rgvarg
= NULL
;
983 VariantInit(&varresult
);
984 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
985 ok_ole_success(hr
, IDispatch_Invoke
);
986 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
987 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
988 excepinfo
.wCode
, excepinfo
.scode
);
989 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult
)));
990 VariantClear(&varresult
);
992 /* call get_Name (direct) */
994 hr
= IWidget_get_Name(pWidget
, &bstr
);
995 ok_ole_success(hr
, IWidget_get_Name
);
996 ok(!lstrcmpW(bstr
, szCat
), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr
));
999 /* call DoSomething */
1000 VariantInit(&vararg
[0]);
1001 VariantInit(&vararg
[1]);
1002 V_VT(&vararg
[1]) = VT_R8
;
1003 V_R8(&vararg
[1]) = 3.141;
1004 dispparams
.cNamedArgs
= 0;
1005 dispparams
.cArgs
= 2;
1006 dispparams
.rgdispidNamedArgs
= NULL
;
1007 dispparams
.rgvarg
= vararg
;
1008 VariantInit(&varresult
);
1009 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_DOSOMETHING
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1010 ok_ole_success(hr
, IDispatch_Invoke
);
1011 ok(V_VT(&varresult
) == VT_EMPTY
, "varresult should be VT_EMPTY\n");
1012 VariantClear(&varresult
);
1014 /* call get_State */
1015 dispparams
.cNamedArgs
= 0;
1016 dispparams
.cArgs
= 0;
1017 dispparams
.rgdispidNamedArgs
= NULL
;
1018 dispparams
.rgvarg
= NULL
;
1019 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1020 ok_ole_success(hr
, IDispatch_Invoke
);
1021 ok((V_VT(&varresult
) == VT_I4
) && (V_I4(&varresult
) == STATE_WIDGETIFIED
), "Return val mismatch\n");
1023 /* call get_State (direct) */
1024 hr
= IWidget_get_State(pWidget
, &the_state
);
1025 ok_ole_success(hr
, IWidget_get_state
);
1026 ok(the_state
== STATE_WIDGETIFIED
, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state
);
1028 /* call put_State */
1029 the_state
= STATE_WIDGETIFIED
;
1030 VariantInit(&vararg
[0]);
1031 V_VT(&vararg
[0]) = VT_BYREF
|VT_I4
;
1032 V_I4REF(&vararg
[0]) = (int *)&the_state
;
1033 dispparams
.cNamedArgs
= 1;
1034 dispparams
.cArgs
= 1;
1035 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1036 dispparams
.rgvarg
= vararg
;
1037 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1038 ok_ole_success(hr
, IDispatch_Invoke
);
1041 bstr
= SysAllocString(szTestTest
);
1042 VariantInit(&vararg
[0]);
1043 V_VT(&vararg
[0]) = VT_BYREF
|VT_BSTR
;
1044 V_BSTRREF(&vararg
[0]) = &bstr
;
1045 dispparams
.cNamedArgs
= 0;
1046 dispparams
.cArgs
= 1;
1047 dispparams
.rgdispidNamedArgs
= NULL
;
1048 dispparams
.rgvarg
= vararg
;
1049 VariantInit(&varresult
);
1050 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_MAP
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1051 ok_ole_success(hr
, IDispatch_Invoke
);
1052 ok(V_VT(&varresult
) == VT_BSTR
, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult
));
1053 ok(!lstrcmpW(V_BSTR(&varresult
), szTestTest
), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult
)));
1054 VariantClear(&varresult
);
1056 /* call SetOleColor with large negative VT_I4 param */
1057 VariantInit(&vararg
[0]);
1058 V_VT(&vararg
[0]) = VT_I4
;
1059 V_I4(&vararg
[0]) = 0x80000005;
1060 dispparams
.cNamedArgs
= 0;
1061 dispparams
.cArgs
= 1;
1062 dispparams
.rgdispidNamedArgs
= NULL
;
1063 dispparams
.rgvarg
= vararg
;
1064 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_SETOLECOLOR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, &excepinfo
, NULL
);
1065 ok_ole_success(hr
, IDispatch_Invoke
);
1067 /* call GetOleColor */
1068 dispparams
.cNamedArgs
= 0;
1069 dispparams
.cArgs
= 0;
1070 dispparams
.rgdispidNamedArgs
= NULL
;
1071 dispparams
.rgvarg
= NULL
;
1072 VariantInit(&varresult
);
1073 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_GETOLECOLOR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1074 ok_ole_success(hr
, IDispatch_Invoke
);
1075 VariantClear(&varresult
);
1077 /* call StructArgs (direct) */
1078 mystruct
= MYSTRUCT_BYPTR
;
1079 memcpy(mystructArray
, MYSTRUCT_ARRAY
, sizeof(mystructArray
));
1080 hr
= IWidget_StructArgs(pWidget
, MYSTRUCT_BYVAL
, &mystruct
, mystructArray
);
1081 ok_ole_success(hr
, IWidget_StructArgs
);
1084 dispparams
.cNamedArgs
= 0;
1085 dispparams
.cArgs
= 0;
1086 dispparams
.rgdispidNamedArgs
= NULL
;
1087 dispparams
.rgvarg
= NULL
;
1088 VariantInit(&varresult
);
1089 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1090 ok_ole_success(hr
, IDispatch_Invoke
);
1091 ok(V_VT(&varresult
) == VT_DISPATCH
, "vt %x\n", V_VT(&varresult
));
1092 VariantClear(&varresult
);
1094 /* call CloneInterface */
1095 dispparams
.cNamedArgs
= 0;
1096 dispparams
.cArgs
= 0;
1097 dispparams
.rgdispidNamedArgs
= NULL
;
1098 dispparams
.rgvarg
= NULL
;
1099 VariantInit(&varresult
);
1100 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONEINTERFACE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1101 ok_ole_success(hr
, IDispatch_Invoke
);
1102 ok(V_VT(&varresult
) == VT_DISPATCH
, "vt %x\n", V_VT(&varresult
));
1103 VariantClear(&varresult
);
1105 /* call CloneDispatch with automatic value getting */
1106 V_VT(&vararg
[0]) = VT_I2
;
1107 V_I2(&vararg
[0]) = 1;
1108 dispparams
.cNamedArgs
= 0;
1109 dispparams
.rgdispidNamedArgs
= NULL
;
1110 dispparams
.cArgs
= 1;
1111 dispparams
.rgvarg
= vararg
;
1112 VariantInit(&varresult
);
1113 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONEDISPATCH
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1114 ok_ole_success(hr
, IDispatch_Invoke
);
1116 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1117 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1118 excepinfo
.wCode
, excepinfo
.scode
);
1120 ok(V_VT(&varresult
) == VT_I2
, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult
));
1121 ok(V_I2(&varresult
) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult
));
1122 VariantClear(&varresult
);
1124 /* call CloneCoclass */
1125 dispparams
.cNamedArgs
= 0;
1126 dispparams
.cArgs
= 0;
1127 dispparams
.rgdispidNamedArgs
= NULL
;
1128 dispparams
.rgvarg
= NULL
;
1129 VariantInit(&varresult
);
1130 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONECOCLASS
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1131 ok_ole_success(hr
, IDispatch_Invoke
);
1133 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1134 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1135 excepinfo
.wCode
, excepinfo
.scode
);
1137 ok(V_VT(&varresult
) == VT_DISPATCH
, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult
));
1138 ok(!V_DISPATCH(&varresult
), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult
));
1139 VariantClear(&varresult
);
1141 /* call Value with a VT_VARIANT|VT_BYREF type */
1142 V_VT(&vararg
[0]) = VT_VARIANT
|VT_BYREF
;
1143 V_VARIANTREF(&vararg
[0]) = &vararg
[1];
1144 V_VT(&vararg
[1]) = VT_I2
;
1145 V_I2(&vararg
[1]) = 1;
1146 dispparams
.cNamedArgs
= 0;
1147 dispparams
.rgdispidNamedArgs
= NULL
;
1148 dispparams
.cArgs
= 1;
1149 dispparams
.rgvarg
= vararg
;
1150 VariantInit(&varresult
);
1151 hr
= IDispatch_Invoke(pDispatch
, DISPID_VALUE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1152 ok_ole_success(hr
, IDispatch_Invoke
);
1154 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1155 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1156 excepinfo
.wCode
, excepinfo
.scode
);
1158 ok(V_VT(&varresult
) == VT_I2
, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult
));
1159 ok(V_I2(&varresult
) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult
));
1160 VariantClear(&varresult
);
1162 /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1163 * handling of void return types */
1164 /* use a big type to ensure that the variant was properly copied into the
1165 * destination function's args */
1166 V_VT(&vararg
[0]) = VT_CY
;
1167 S(V_CY(&vararg
[0])).Hi
= 0xdababe;
1168 S(V_CY(&vararg
[0])).Lo
= 0xdeadbeef;
1169 dispparams
.cNamedArgs
= 0;
1170 dispparams
.cArgs
= 1;
1171 dispparams
.rgdispidNamedArgs
= NULL
;
1172 dispparams
.rgvarg
= vararg
;
1173 VariantInit(&varresult
);
1174 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARIANT
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1175 ok_ole_success(hr
, IDispatch_Invoke
);
1176 VariantClear(&varresult
);
1179 VariantInit(&vararg
[3]);
1180 V_VT(&vararg
[3]) = VT_I4
;
1181 V_I4(&vararg
[3]) = 3;
1182 VariantInit(&vararg
[2]);
1183 V_VT(&vararg
[2]) = VT_I4
;
1184 V_I4(&vararg
[2]) = 0;
1185 VariantInit(&vararg
[1]);
1186 V_VT(&vararg
[1]) = VT_I4
;
1187 V_I4(&vararg
[1]) = 1;
1188 VariantInit(&vararg
[0]);
1189 V_VT(&vararg
[0]) = VT_I4
;
1190 V_I4(&vararg
[0]) = 2;
1191 dispparams
.cNamedArgs
= 0;
1192 dispparams
.cArgs
= 4;
1193 dispparams
.rgdispidNamedArgs
= NULL
;
1194 dispparams
.rgvarg
= vararg
;
1195 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARARG
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1196 ok_ole_success(hr
, ITypeInfo_Invoke
);
1198 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1200 dispparams
.cNamedArgs
= 1;
1201 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1202 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARARG
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1203 ok(hr
== DISP_E_NONAMEDARGS
, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr
);
1204 dispidNamed
= DISPID_PROPERTYPUT
;
1207 dispparams
.cNamedArgs
= 0;
1208 dispparams
.cArgs
= 0;
1209 dispparams
.rgdispidNamedArgs
= NULL
;
1210 dispparams
.rgvarg
= NULL
;
1211 VariantInit(&varresult
);
1212 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_ERROR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, &excepinfo
, NULL
);
1213 ok(hr
== DISP_E_EXCEPTION
, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr
);
1214 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== E_NOTIMPL
,
1215 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1216 excepinfo
.wCode
, excepinfo
.scode
);
1217 VariantClear(&varresult
);
1220 pTypeInfo
= NonOleAutomation_GetTypeInfo();
1221 dispparams
.cNamedArgs
= 0;
1222 dispparams
.cArgs
= 0;
1223 dispparams
.rgdispidNamedArgs
= NULL
;
1224 dispparams
.rgvarg
= NULL
;
1225 VariantInit(&varresult
);
1226 hr
= ITypeInfo_Invoke(pTypeInfo
, &NonOleAutomation
, DISPID_NOA_BSTRRET
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1227 ok_ole_success(hr
, ITypeInfo_Invoke
);
1228 ok(V_VT(&varresult
) == VT_BSTR
, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult
));
1229 ok(V_BSTR(&varresult
) != NULL
, "V_BSTR(&varresult) should not be NULL\n");
1231 VariantClear(&varresult
);
1232 ITypeInfo_Release(pTypeInfo
);
1234 /* tests call put_Name without named arg */
1235 VariantInit(&vararg
[0]);
1236 dispparams
.cNamedArgs
= 0;
1237 dispparams
.rgdispidNamedArgs
= NULL
;
1238 dispparams
.cArgs
= 1;
1239 dispparams
.rgvarg
= vararg
;
1240 VariantInit(&varresult
);
1241 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1242 ok(hr
== DISP_E_PARAMNOTFOUND
, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr
);
1243 VariantClear(&varresult
);
1245 /* tests param type that cannot be coerced */
1246 VariantInit(&vararg
[0]);
1247 V_VT(&vararg
[0]) = VT_UNKNOWN
;
1248 V_UNKNOWN(&vararg
[0]) = NULL
;
1249 dispparams
.cNamedArgs
= 1;
1250 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1251 dispparams
.cArgs
= 1;
1252 dispparams
.rgvarg
= vararg
;
1253 VariantInit(&varresult
);
1254 #if 0 /* NULL unknown not currently marshaled correctly */
1255 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1256 ok(hr
== DISP_E_TYPEMISMATCH
, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr
);
1258 VariantClear(&varresult
);
1260 /* tests bad param type */
1261 VariantInit(&vararg
[0]);
1262 V_VT(&vararg
[0]) = VT_CLSID
;
1263 V_BYREF(&vararg
[0]) = NULL
;
1264 dispparams
.cNamedArgs
= 1;
1265 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1266 dispparams
.cArgs
= 1;
1267 dispparams
.rgvarg
= vararg
;
1268 VariantInit(&varresult
);
1269 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1270 ok(hr
== DISP_E_BADVARTYPE
, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr
);
1271 VariantClear(&varresult
);
1273 /* tests too small param count */
1274 dispparams
.cNamedArgs
= 0;
1275 dispparams
.rgdispidNamedArgs
= NULL
;
1276 dispparams
.cArgs
= 0;
1277 dispparams
.rgvarg
= NULL
;
1278 VariantInit(&varresult
);
1279 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_DOSOMETHING
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1280 ok(hr
== DISP_E_BADPARAMCOUNT
, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr
);
1281 VariantClear(&varresult
);
1283 /* tests propget function with large param count */
1284 VariantInit(&vararg
[0]);
1285 V_VT(&vararg
[0]) = VT_BSTR
;
1286 V_BSTR(&vararg
[0]) = NULL
;
1287 V_VT(&vararg
[1]) = VT_I4
;
1288 V_I4(&vararg
[1]) = 1;
1289 dispparams
.cNamedArgs
= 0;
1290 dispparams
.cArgs
= 2;
1291 dispparams
.rgdispidNamedArgs
= NULL
;
1292 dispparams
.rgvarg
= vararg
;
1293 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1294 ok(hr
== DISP_E_NOTACOLLECTION
, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr
);
1296 /* test propput with lcid */
1298 /* the lcid passed to the function is the first lcid in the typelib header.
1299 Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1300 VariantInit(&vararg
[0]);
1301 V_VT(&vararg
[0]) = VT_I4
;
1302 V_I4(&vararg
[0]) = 0xcafe;
1303 dispparams
.cNamedArgs
= 1;
1304 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1305 dispparams
.cArgs
= 1;
1306 dispparams
.rgvarg
= vararg
;
1307 VariantInit(&varresult
);
1308 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_PROP_WITH_LCID
, &IID_NULL
, 0x40c, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1309 ok_ole_success(hr
, ITypeInfo_Invoke
);
1310 VariantClear(&varresult
);
1312 /* test propget with lcid */
1313 dispparams
.cNamedArgs
= 0;
1314 dispparams
.cArgs
= 0;
1315 dispparams
.rgvarg
= NULL
;
1316 dispparams
.rgdispidNamedArgs
= NULL
;
1317 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_PROP_WITH_LCID
, &IID_NULL
, 0x40c, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1318 ok_ole_success(hr
, ITypeInfo_Invoke
);
1319 ok(V_VT(&varresult
) == VT_I4
, "got %x\n", V_VT(&varresult
));
1320 ok(V_I4(&varresult
) == 0x409, "got %x\n", V_I4(&varresult
));
1321 VariantClear(&varresult
);
1323 /* test propget of INT value */
1324 dispparams
.cNamedArgs
= 0;
1325 dispparams
.cArgs
= 0;
1326 dispparams
.rgvarg
= NULL
;
1327 dispparams
.rgdispidNamedArgs
= NULL
;
1328 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_PROP_INT
, &IID_NULL
, 0x40c, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1329 ok_ole_success(hr
, ITypeInfo_Invoke
);
1330 ok(V_VT(&varresult
) == VT_I4
, "got %x\n", V_VT(&varresult
));
1331 ok(V_I4(&varresult
) == -13, "got %x\n", V_I4(&varresult
));
1332 VariantClear(&varresult
);
1334 /* test propget of INT value */
1335 dispparams
.cNamedArgs
= 0;
1336 dispparams
.cArgs
= 0;
1337 dispparams
.rgvarg
= NULL
;
1338 dispparams
.rgdispidNamedArgs
= NULL
;
1339 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_PROP_UINT
, &IID_NULL
, 0x40c, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1340 ok_ole_success(hr
, ITypeInfo_Invoke
);
1341 ok(V_VT(&varresult
) == VT_UI4
, "got %x\n", V_VT(&varresult
));
1342 ok(V_UI4(&varresult
) == 42, "got %x\n", V_UI4(&varresult
));
1343 VariantClear(&varresult
);
1345 IDispatch_Release(pDispatch
);
1346 IWidget_Release(pWidget
);
1348 trace("calling end_host_object\n");
1349 end_host_object(tid
, thread
);
1352 static void test_DispCallFunc(void)
1354 static const WCHAR szEmpty
[] = { 0 };
1355 VARTYPE rgvt
[] = { VT_R8
, VT_BSTR
, VT_BSTR
, VT_VARIANT
|VT_BYREF
};
1356 VARIANTARG vararg
[4];
1358 VARIANTARG
*rgpvarg
[4] = { &vararg
[0], &vararg
[1], &vararg
[2], &vararg
[3] };
1359 VARIANTARG varresult
;
1361 IWidget
*pWidget
= Widget_Create();
1362 V_VT(&vararg
[0]) = VT_R8
;
1363 V_R8(&vararg
[0]) = 3.141;
1364 V_VT(&vararg
[1]) = VT_BSTR
;
1365 V_BSTR(&vararg
[1]) = SysAllocString(szEmpty
);
1366 V_VT(&vararg
[2]) = VT_BSTR
;
1367 V_BSTR(&vararg
[2]) = SysAllocString(szEmpty
);
1368 V_VT(&vararg
[3]) = VT_VARIANT
|VT_BYREF
;
1369 V_VARIANTREF(&vararg
[3]) = &varref
;
1370 V_VT(&varref
) = VT_ERROR
;
1371 V_ERROR(&varref
) = DISP_E_PARAMNOTFOUND
;
1372 VariantInit(&varresult
);
1373 hr
= DispCallFunc(pWidget
, 9*sizeof(void*), CC_STDCALL
, VT_UI4
, 4, rgvt
, rgpvarg
, &varresult
);
1374 ok_ole_success(hr
, DispCallFunc
);
1375 VariantClear(&varresult
);
1376 VariantClear(&vararg
[1]);
1377 VariantClear(&vararg
[2]);
1378 IWidget_Release(pWidget
);
1381 static void test_StaticWidget(void)
1383 ITypeInfo
*type_info
;
1384 DISPPARAMS dispparams
;
1385 VARIANTARG vararg
[4];
1386 EXCEPINFO excepinfo
;
1390 type_info
= get_type_info(&IID_IStaticWidget
);
1393 dispparams
.cNamedArgs
= 0;
1394 dispparams
.cArgs
= 1;
1395 dispparams
.rgdispidNamedArgs
= NULL
;
1396 dispparams
.rgvarg
= vararg
;
1397 V_VT(vararg
) = VT_DISPATCH
;
1398 V_DISPATCH(vararg
) = (IDispatch
*)&TestDualDisp
;
1399 VariantInit(&varresult
);
1400 hr
= ITypeInfo_Invoke(type_info
, &StaticWidget
, DISPID_TM_TESTDUAL
, DISPATCH_METHOD
,
1401 &dispparams
, &varresult
, &excepinfo
, NULL
);
1402 ok_ole_success(hr
, IDispatch_Invoke
);
1403 ok(V_VT(&varresult
) == VT_EMPTY
, "vt %x\n", V_VT(&varresult
));
1404 VariantClear(&varresult
);
1406 ITypeInfo_Release(type_info
);
1409 static void test_libattr(void)
1415 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
1416 ok_ole_success(hr
, LoadRegTypeLib
);
1420 hr
= ITypeLib_GetLibAttr(pTypeLib
, &pattr
);
1421 ok_ole_success(hr
, GetLibAttr
);
1424 ok(pattr
->lcid
== MAKELANGID(LANG_NEUTRAL
, SUBLANG_NEUTRAL
), "lcid %x\n", pattr
->lcid
);
1426 ITypeLib_ReleaseTLibAttr(pTypeLib
, pattr
);
1429 ITypeLib_Release(pTypeLib
);
1432 START_TEST(tmarshal
)
1436 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
1438 hr
= register_current_module_typelib();
1439 ok_ole_success(hr
, register_current_module_typelib
);
1441 test_typelibmarshal();
1442 test_DispCallFunc();
1443 test_StaticWidget();
1446 hr
= UnRegisterTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
,
1447 sizeof(void*) == 8 ? SYS_WIN64
: SYS_WIN32
);
1448 ok_ole_success(hr
, UnRegisterTypeLib
);