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)},
47 /* Debugging functions from wine/libs/wine/debug.c */
49 /* allocate some tmp string space */
50 /* FIXME: this is not 100% thread-safe */
51 static char *get_tmp_space( int size
)
53 static char *list
[32];
58 idx
= ++pos
% (sizeof(list
)/sizeof(list
[0]));
60 ret
= HeapReAlloc( GetProcessHeap(), 0, list
[idx
], size
);
62 ret
= HeapAlloc( GetProcessHeap(), 0, size
);
63 if (ret
) list
[idx
] = ret
;
67 /* default implementation of wine_dbgstr_wn */
68 static const char *default_dbgstr_wn( const WCHAR
*str
, int n
)
74 if (!str
) return "(null)";
75 res
= get_tmp_space( 6 );
76 sprintf( res
, "#%04x", LOWORD(str
) );
79 if (n
== -1) n
= lstrlenW(str
);
81 else if (n
> 200) n
= 200;
82 dst
= res
= get_tmp_space( n
* 5 + 7 );
90 case '\n': *dst
++ = '\\'; *dst
++ = 'n'; break;
91 case '\r': *dst
++ = '\\'; *dst
++ = 'r'; break;
92 case '\t': *dst
++ = '\\'; *dst
++ = 't'; break;
93 case '"': *dst
++ = '\\'; *dst
++ = '"'; break;
94 case '\\': *dst
++ = '\\'; *dst
++ = '\\'; break;
96 if (c
>= ' ' && c
<= 126)
101 sprintf(dst
,"%04x",c
);
117 const char *wine_dbgstr_wn( const WCHAR
*s
, int n
)
119 return default_dbgstr_wn(s
, n
);
122 const char *wine_dbgstr_w( const WCHAR
*s
)
124 return default_dbgstr_wn( s
, -1 );
128 #define RELEASEMARSHALDATA WM_USER
130 struct host_object_data
135 MSHLFLAGS marshal_flags
;
136 HANDLE marshal_event
;
137 IMessageFilter
*filter
;
140 static DWORD CALLBACK
host_object_proc(LPVOID p
)
142 struct host_object_data
*data
= p
;
146 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
150 IMessageFilter
* prev_filter
= NULL
;
151 hr
= CoRegisterMessageFilter(data
->filter
, &prev_filter
);
152 if (prev_filter
) IMessageFilter_Release(prev_filter
);
153 ok_ole_success(hr
, CoRegisterMessageFilter
);
156 hr
= CoMarshalInterface(data
->stream
, &data
->iid
, data
->object
, MSHCTX_INPROC
, NULL
, data
->marshal_flags
);
157 ok_ole_success(hr
, CoMarshalInterface
);
159 /* force the message queue to be created before signaling parent thread */
160 PeekMessage(&msg
, NULL
, WM_USER
, WM_USER
, PM_NOREMOVE
);
162 SetEvent(data
->marshal_event
);
164 while (GetMessage(&msg
, NULL
, 0, 0))
166 if (msg
.hwnd
== NULL
&& msg
.message
== RELEASEMARSHALDATA
)
168 trace("releasing marshal data\n");
169 CoReleaseMarshalData(data
->stream
);
170 SetEvent((HANDLE
)msg
.lParam
);
173 DispatchMessage(&msg
);
176 HeapFree(GetProcessHeap(), 0, data
);
183 static DWORD
start_host_object2(IStream
*stream
, REFIID riid
, IUnknown
*object
, MSHLFLAGS marshal_flags
, IMessageFilter
*filter
, HANDLE
*thread
)
186 HANDLE marshal_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
187 struct host_object_data
*data
= HeapAlloc(GetProcessHeap(), 0, sizeof(*data
));
189 data
->stream
= stream
;
191 data
->object
= object
;
192 data
->marshal_flags
= marshal_flags
;
193 data
->marshal_event
= marshal_event
;
194 data
->filter
= filter
;
196 *thread
= CreateThread(NULL
, 0, host_object_proc
, data
, 0, &tid
);
198 /* wait for marshaling to complete before returning */
199 WaitForSingleObject(marshal_event
, INFINITE
);
200 CloseHandle(marshal_event
);
205 static DWORD
start_host_object(IStream
*stream
, REFIID riid
, IUnknown
*object
, MSHLFLAGS marshal_flags
, HANDLE
*thread
)
207 return start_host_object2(stream
, riid
, object
, marshal_flags
, NULL
, thread
);
211 /* asks thread to release the marshal data because it has to be done by the
212 * same thread that marshaled the interface in the first place. */
213 static void release_host_object(DWORD tid
)
215 HANDLE event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
216 PostThreadMessage(tid
, RELEASEMARSHALDATA
, 0, (LPARAM
)event
);
217 WaitForSingleObject(event
, INFINITE
);
222 static void end_host_object(DWORD tid
, HANDLE thread
)
224 BOOL ret
= PostThreadMessage(tid
, WM_QUIT
, 0, 0);
225 ok(ret
, "PostThreadMessage failed with error %d\n", GetLastError());
226 /* be careful of races - don't return until hosting thread has terminated */
227 WaitForSingleObject(thread
, INFINITE
);
231 static ItestDual TestDual
, TestDualDisp
;
233 static HRESULT WINAPI
TestDual_QueryInterface(ItestDual
*iface
, REFIID riid
, void **ppvObject
)
235 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
)) {
236 *ppvObject
= &TestDualDisp
;
238 }else if(IsEqualGUID(riid
, &IID_ItestDual
)) {
239 *ppvObject
= &TestDual
;
244 return E_NOINTERFACE
;
247 static ULONG WINAPI
TestDual_AddRef(ItestDual
*iface
)
252 static ULONG WINAPI
TestDual_Release(ItestDual
*iface
)
257 static HRESULT WINAPI
TestDual_GetTypeInfoCount(ItestDual
*iface
, UINT
*pctinfo
)
259 ok(0, "unexpected call\n");
263 static HRESULT WINAPI
TestDual_GetTypeInfo(ItestDual
*iface
, UINT iTInfo
, LCID lcid
, ITypeInfo
**ppTInfo
)
265 ok(0, "unexpected call\n");
269 static HRESULT WINAPI
TestDual_GetIDsOfNames(ItestDual
*iface
, REFIID riid
, LPOLESTR
*rgszNames
,
270 UINT cNames
, LCID lcid
, DISPID
*rgDispId
)
272 ok(0, "unexpected call\n");
276 static HRESULT WINAPI
TestDual_Invoke(ItestDual
*iface
, DISPID dispIdMember
, REFIID riid
, LCID lcid
,
277 WORD wFlags
, DISPPARAMS
*pDispParams
, VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
,
280 ok(0, "unexpected call\n");
284 static ItestDualVtbl TestDualVtbl
= {
285 TestDual_QueryInterface
,
288 TestDual_GetTypeInfoCount
,
289 TestDual_GetTypeInfo
,
290 TestDual_GetIDsOfNames
,
294 static ItestDual TestDual
= { &TestDualVtbl
};
295 static ItestDual TestDualDisp
= { &TestDualVtbl
};
297 typedef struct Widget
299 const IWidgetVtbl
*lpVtbl
;
301 IUnknown
*pDispatchUnknown
;
304 static HRESULT WINAPI
Widget_QueryInterface(
306 /* [in] */ REFIID riid
,
307 /* [iid_is][out] */ void __RPC_FAR
*__RPC_FAR
*ppvObject
)
309 if (IsEqualIID(riid
, &IID_IWidget
) || IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
))
311 IWidget_AddRef(iface
);
318 return E_NOINTERFACE
;
322 static ULONG WINAPI
Widget_AddRef(
325 Widget
*This
= (Widget
*)iface
;
327 return InterlockedIncrement(&This
->refs
);
330 static ULONG WINAPI
Widget_Release(
333 Widget
*This
= (Widget
*)iface
;
334 ULONG refs
= InterlockedDecrement(&This
->refs
);
337 IUnknown_Release(This
->pDispatchUnknown
);
338 memset(This
, 0xcc, sizeof(*This
));
339 HeapFree(GetProcessHeap(), 0, This
);
340 trace("Widget destroyed!\n");
346 static HRESULT WINAPI
Widget_GetTypeInfoCount(
348 /* [out] */ UINT __RPC_FAR
*pctinfo
)
350 Widget
*This
= (Widget
*)iface
;
351 IDispatch
*pDispatch
;
352 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
355 hr
= IDispatch_GetTypeInfoCount(pDispatch
, pctinfo
);
356 IDispatch_Release(pDispatch
);
361 static HRESULT WINAPI
Widget_GetTypeInfo(
362 IWidget __RPC_FAR
* iface
,
363 /* [in] */ UINT iTInfo
,
364 /* [in] */ LCID lcid
,
365 /* [out] */ ITypeInfo __RPC_FAR
*__RPC_FAR
*ppTInfo
)
367 Widget
*This
= (Widget
*)iface
;
368 IDispatch
*pDispatch
;
369 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
372 hr
= IDispatch_GetTypeInfo(pDispatch
, iTInfo
, lcid
, ppTInfo
);
373 IDispatch_Release(pDispatch
);
378 static HRESULT WINAPI
Widget_GetIDsOfNames(
379 IWidget __RPC_FAR
* iface
,
380 /* [in] */ REFIID riid
,
381 /* [size_is][in] */ LPOLESTR __RPC_FAR
*rgszNames
,
382 /* [in] */ UINT cNames
,
383 /* [in] */ LCID lcid
,
384 /* [size_is][out] */ DISPID __RPC_FAR
*rgDispId
)
386 Widget
*This
= (Widget
*)iface
;
387 IDispatch
*pDispatch
;
388 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
391 hr
= IDispatch_GetIDsOfNames(pDispatch
, riid
, rgszNames
, cNames
, lcid
, rgDispId
);
392 IDispatch_Release(pDispatch
);
397 static HRESULT WINAPI
Widget_Invoke(
398 IWidget __RPC_FAR
* iface
,
399 /* [in] */ DISPID dispIdMember
,
400 /* [in] */ REFIID riid
,
401 /* [in] */ LCID lcid
,
402 /* [in] */ WORD wFlags
,
403 /* [out][in] */ DISPPARAMS __RPC_FAR
*pDispParams
,
404 /* [out] */ VARIANT __RPC_FAR
*pVarResult
,
405 /* [out] */ EXCEPINFO __RPC_FAR
*pExcepInfo
,
406 /* [out] */ UINT __RPC_FAR
*puArgErr
)
408 Widget
*This
= (Widget
*)iface
;
409 IDispatch
*pDispatch
;
410 HRESULT hr
= IUnknown_QueryInterface(This
->pDispatchUnknown
, &IID_IDispatch
, (void **)&pDispatch
);
413 hr
= IDispatch_Invoke(pDispatch
, dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
414 IDispatch_Release(pDispatch
);
419 static HRESULT WINAPI
Widget_put_Name(
420 IWidget __RPC_FAR
* iface
,
421 /* [in] */ BSTR name
)
423 trace("put_Name(%s)\n", wine_dbgstr_w(name
));
427 static HRESULT WINAPI
Widget_get_Name(
428 IWidget __RPC_FAR
* iface
,
429 /* [out] */ BSTR __RPC_FAR
*name
)
431 static const WCHAR szCat
[] = { 'C','a','t',0 };
432 trace("get_Name()\n");
433 *name
= SysAllocString(szCat
);
437 static HRESULT WINAPI
Widget_DoSomething(
438 IWidget __RPC_FAR
* iface
,
439 /* [in] */ double number
,
440 /* [out] */ BSTR
*str1
,
441 /* [defaultvalue][in] */ BSTR str2
,
442 /* [optional][in] */ VARIANT __RPC_FAR
*opt
)
444 static const WCHAR szString
[] = { 'S','t','r','i','n','g',0 };
445 trace("DoSomething()\n");
447 ok(number
== 3.141, "number(%f) != 3.141\n", number
);
448 ok(*str2
== '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2
));
449 ok(V_VT(opt
) == VT_ERROR
, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt
));
450 ok(V_ERROR(opt
) == DISP_E_PARAMNOTFOUND
, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt
));
451 *str1
= SysAllocString(szString
);
456 static HRESULT WINAPI
Widget_get_State(
457 IWidget __RPC_FAR
* iface
,
458 /* [retval][out] */ STATE __RPC_FAR
*state
)
460 trace("get_State() = STATE_WIDGETIFIED\n");
461 *state
= STATE_WIDGETIFIED
;
465 static HRESULT WINAPI
Widget_put_State(
466 IWidget __RPC_FAR
* iface
,
467 /* [in] */ STATE state
)
469 trace("put_State(%d)\n", state
);
473 static HRESULT WINAPI
Widget_Map(
478 trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId
), sValue
);
479 *sValue
= SysAllocString(bstrId
);
483 static HRESULT WINAPI
Widget_SetOleColor(
487 trace("SetOleColor(0x%x)\n", val
);
491 static HRESULT WINAPI
Widget_GetOleColor(
495 trace("GetOleColor() = 0x8000000f\n");
500 static HRESULT WINAPI
Widget_Clone(
505 return Widget_QueryInterface(iface
, &IID_IWidget
, (void **)ppVal
);
508 static HRESULT WINAPI
Widget_CloneDispatch(
512 trace("CloneDispatch()\n");
513 return Widget_QueryInterface(iface
, &IID_IWidget
, (void **)ppVal
);
516 static HRESULT WINAPI
Widget_CloneCoclass(
518 ApplicationObject2
**ppVal
)
520 trace("CloneCoclass()\n");
524 static HRESULT WINAPI
Widget_Value(
525 IWidget __RPC_FAR
* iface
,
529 trace("Value(%p, %p)\n", value
, retval
);
530 ok(V_VT(value
) == VT_I2
, "V_VT(value) was %d instead of VT_I2\n", V_VT(value
));
531 ok(V_I2(value
) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value
));
532 V_VT(retval
) = VT_I2
;
537 static HRESULT WINAPI
Widget_Array(
541 trace("Array(%p)\n", values
);
545 static HRESULT WINAPI
Widget_VariantArrayPtr(
549 trace("VariantArrayPtr(%p)\n", values
);
553 static HRESULT WINAPI
Widget_Variant(
554 IWidget __RPC_FAR
* iface
,
557 trace("Variant()\n");
558 ok(V_VT(&var
) == VT_CY
, "V_VT(&var) was %d\n", V_VT(&var
));
559 ok(S(V_CY(&var
)).Hi
== 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var
)).Hi
);
560 ok(S(V_CY(&var
)).Lo
== 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var
)).Lo
);
564 static HRESULT WINAPI
Widget_VarArg(
569 LONG lbound
, ubound
, i
;
573 trace("VarArg(%p)\n", values
);
575 hr
= SafeArrayGetLBound(values
, 1, &lbound
);
576 ok(hr
== S_OK
, "SafeArrayGetLBound failed with %x\n", hr
);
577 ok(lbound
== 0, "SafeArrayGetLBound returned %d\n", lbound
);
579 hr
= SafeArrayGetUBound(values
, 1, &ubound
);
580 ok(hr
== S_OK
, "SafeArrayGetUBound failed with %x\n", hr
);
581 ok(ubound
== numexpect
-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound
, numexpect
-1);
583 hr
= SafeArrayAccessData(values
, (LPVOID
)&data
);
584 ok(hr
== S_OK
, "SafeArrayAccessData failed with %x\n", hr
);
586 for (i
=0; i
<=ubound
-lbound
; i
++)
588 ok(V_VT(&data
[i
]) == VT_I4
, "V_VT(&data[%d]) was %d\n", i
, V_VT(&data
[i
]));
589 ok(V_I4(&data
[i
]) == i
, "V_I4(&data[%d]) was %d\n", i
, V_I4(&data
[i
]));
592 hr
= SafeArrayUnaccessData(values
);
593 ok(hr
== S_OK
, "SafeArrayUnaccessData failed with %x\n", hr
);
598 static HRESULT WINAPI
Widget_StructArgs(
604 ok(memcmp(&byval
, &MYSTRUCT_BYVAL
, sizeof(MYSTRUCT
))==0, "Struct parameter passed by value corrupted\n");
605 ok(memcmp(byptr
, &MYSTRUCT_BYPTR
, sizeof(MYSTRUCT
))==0, "Struct parameter passed by pointer corrupted\n");
606 ok(memcmp(arr
, MYSTRUCT_ARRAY
, sizeof(MYSTRUCT_ARRAY
))==0, "Array of structs corrupted\n");
611 static HRESULT WINAPI
Widget_Error(
612 IWidget __RPC_FAR
* iface
)
618 static HRESULT WINAPI
Widget_CloneInterface(
619 IWidget __RPC_FAR
* iface
,
620 ISomethingFromDispatch
**ppVal
)
622 trace("CloneInterface()\n");
627 static const struct IWidgetVtbl Widget_VTable
=
629 Widget_QueryInterface
,
632 Widget_GetTypeInfoCount
,
634 Widget_GetIDsOfNames
,
645 Widget_CloneDispatch
,
649 Widget_VariantArrayPtr
,
654 Widget_CloneInterface
657 static HRESULT WINAPI
StaticWidget_QueryInterface(IStaticWidget
*iface
, REFIID riid
, void **ppvObject
)
659 if (IsEqualIID(riid
, &IID_IStaticWidget
) || IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
))
661 IStaticWidget_AddRef(iface
);
667 return E_NOINTERFACE
;
670 static ULONG WINAPI
StaticWidget_AddRef(IStaticWidget
*iface
)
675 static ULONG WINAPI
StaticWidget_Release(IStaticWidget
*iface
)
680 static HRESULT WINAPI
StaticWidget_GetTypeInfoCount(IStaticWidget
*iface
, UINT
*pctinfo
)
682 ok(0, "unexpected call\n");
686 static HRESULT WINAPI
StaticWidget_GetTypeInfo(IStaticWidget
*iface
, UINT iTInfo
, LCID lcid
,
689 ok(0, "unexpected call\n");
693 static HRESULT WINAPI
StaticWidget_GetIDsOfNames(IStaticWidget
*iface
, REFIID riid
, LPOLESTR
*rgszNames
,
694 UINT cNames
, LCID lcid
, DISPID
*rgDispId
)
696 ok(0, "unexpected call\n");
700 static HRESULT WINAPI
StaticWidget_Invoke(IStaticWidget
*iface
, DISPID dispIdMember
, REFIID riid
,
701 LCID lcid
, WORD wFlags
, DISPPARAMS
*pDispParams
, VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
,
704 ok(0, "unexpected call\n");
708 static HRESULT WINAPI
StaticWidget_TestDual(IStaticWidget
*iface
, ItestDual
*p
)
710 trace("TestDual()\n");
712 ok(p
== &TestDual
, "wrong ItestDual\n");
716 static const IStaticWidgetVtbl StaticWidgetVtbl
= {
717 StaticWidget_QueryInterface
,
719 StaticWidget_Release
,
720 StaticWidget_GetTypeInfoCount
,
721 StaticWidget_GetTypeInfo
,
722 StaticWidget_GetIDsOfNames
,
724 StaticWidget_TestDual
727 static IStaticWidget StaticWidget
= { &StaticWidgetVtbl
};
729 typedef struct KindaEnum
731 const IKindaEnumWidgetVtbl
*lpVtbl
;
735 static HRESULT
register_current_module_typelib(void)
737 WCHAR path
[MAX_PATH
];
738 CHAR pathA
[MAX_PATH
];
742 GetModuleFileNameA(NULL
, pathA
, MAX_PATH
);
743 MultiByteToWideChar(CP_ACP
, 0, pathA
, -1, path
, MAX_PATH
);
745 hr
= LoadTypeLib(path
, &typelib
);
748 hr
= RegisterTypeLib(typelib
, path
, NULL
);
749 ITypeLib_Release(typelib
);
754 static ITypeInfo
*get_type_info(REFIID riid
)
756 ITypeInfo
*pTypeInfo
;
760 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
761 ok_ole_success(hr
, LoadRegTypeLib
);
765 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, riid
, &pTypeInfo
);
766 ITypeLib_Release(pTypeLib
);
767 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
774 static IWidget
*Widget_Create(void)
777 ITypeInfo
*pTypeInfo
;
780 pTypeInfo
= get_type_info(&IID_IWidget
);
784 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
785 This
->lpVtbl
= &Widget_VTable
;
787 This
->pDispatchUnknown
= NULL
;
789 hr
= CreateStdDispatch((IUnknown
*)&This
->lpVtbl
, This
, pTypeInfo
, &This
->pDispatchUnknown
);
790 ok_ole_success(hr
, CreateStdDispatch
);
791 ITypeInfo_Release(pTypeInfo
);
794 return (IWidget
*)&This
->lpVtbl
;
797 HeapFree(GetProcessHeap(), 0, This
);
802 static HRESULT WINAPI
KindaEnum_QueryInterface(
803 IKindaEnumWidget
*iface
,
804 /* [in] */ REFIID riid
,
805 /* [iid_is][out] */ void __RPC_FAR
*__RPC_FAR
*ppvObject
)
807 if (IsEqualIID(riid
, &IID_IKindaEnumWidget
) || IsEqualIID(riid
, &IID_IUnknown
))
809 IKindaEnumWidget_AddRef(iface
);
816 return E_NOINTERFACE
;
820 static ULONG WINAPI
KindaEnum_AddRef(
821 IKindaEnumWidget
*iface
)
823 KindaEnum
*This
= (KindaEnum
*)iface
;
825 return InterlockedIncrement(&This
->refs
);
828 static ULONG WINAPI
KindaEnum_Release(
829 IKindaEnumWidget
*iface
)
831 KindaEnum
*This
= (KindaEnum
*)iface
;
832 ULONG refs
= InterlockedDecrement(&This
->refs
);
835 memset(This
, 0xcc, sizeof(*This
));
836 HeapFree(GetProcessHeap(), 0, This
);
837 trace("KindaEnumWidget destroyed!\n");
843 static HRESULT WINAPI
KindaEnum_Next(
844 IKindaEnumWidget
*iface
,
845 /* [out] */ IWidget __RPC_FAR
*__RPC_FAR
*widget
)
847 *widget
= Widget_Create();
851 return E_OUTOFMEMORY
;
854 static HRESULT WINAPI
KindaEnum_Count(
855 IKindaEnumWidget
*iface
,
856 /* [out] */ ULONG __RPC_FAR
*count
)
861 static HRESULT WINAPI
KindaEnum_Reset(
862 IKindaEnumWidget
*iface
)
867 static HRESULT WINAPI
KindaEnum_Clone(
868 IKindaEnumWidget
*iface
,
869 /* [out] */ IKindaEnumWidget __RPC_FAR
*__RPC_FAR
*ppenum
)
874 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable
=
876 KindaEnum_QueryInterface
,
885 static IKindaEnumWidget
*KindaEnumWidget_Create(void)
889 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
890 if (!This
) return NULL
;
891 This
->lpVtbl
= &KindaEnumWidget_VTable
;
893 return (IKindaEnumWidget
*)This
;
896 static HRESULT WINAPI
NonOleAutomation_QueryInterface(INonOleAutomation
*iface
, REFIID riid
, void **ppv
)
898 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_INonOleAutomation
))
900 *(INonOleAutomation
**)ppv
= iface
;
904 return E_NOINTERFACE
;
907 static ULONG WINAPI
NonOleAutomation_AddRef(INonOleAutomation
*iface
)
912 static ULONG WINAPI
NonOleAutomation_Release(INonOleAutomation
*iface
)
917 static BSTR WINAPI
NonOleAutomation_BstrRet(INonOleAutomation
*iface
)
919 static const WCHAR wszTestString
[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
920 return SysAllocString(wszTestString
);
923 static INonOleAutomationVtbl NonOleAutomation_VTable
=
925 NonOleAutomation_QueryInterface
,
926 NonOleAutomation_AddRef
,
927 NonOleAutomation_Release
,
928 NonOleAutomation_BstrRet
,
931 static INonOleAutomation NonOleAutomation
= { &NonOleAutomation_VTable
};
933 static ITypeInfo
*NonOleAutomation_GetTypeInfo(void)
936 HRESULT hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
937 ok_ole_success(hr
, LoadRegTypeLib
);
940 ITypeInfo
*pTypeInfo
;
941 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_INonOleAutomation
, &pTypeInfo
);
942 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
948 static void test_typelibmarshal(void)
950 static const WCHAR szCat
[] = { 'C','a','t',0 };
951 static const WCHAR szTestTest
[] = { 'T','e','s','t','T','e','s','t',0 };
952 static WCHAR szSuperman
[] = { 'S','u','p','e','r','m','a','n',0 };
954 IKindaEnumWidget
*pKEW
= KindaEnumWidget_Create();
957 IDispatch
*pDispatch
;
958 static const LARGE_INTEGER ullZero
;
961 DISPID dispidNamed
= DISPID_PROPERTYPUT
;
962 DISPPARAMS dispparams
;
963 VARIANTARG vararg
[4];
968 ITypeInfo
*pTypeInfo
;
970 MYSTRUCT mystructArray
[5];
972 ok(pKEW
!= NULL
, "Widget creation failed\n");
974 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
975 ok_ole_success(hr
, CreateStreamOnHGlobal
);
976 tid
= start_host_object(pStream
, &IID_IKindaEnumWidget
, (IUnknown
*)pKEW
, MSHLFLAGS_NORMAL
, &thread
);
977 IKindaEnumWidget_Release(pKEW
);
979 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
980 hr
= CoUnmarshalInterface(pStream
, &IID_IKindaEnumWidget
, (void **)&pKEW
);
981 ok_ole_success(hr
, CoUnmarshalInterface
);
982 IStream_Release(pStream
);
984 hr
= IKindaEnumWidget_Next(pKEW
, &pWidget
);
985 ok_ole_success(hr
, IKindaEnumWidget_Next
);
987 IKindaEnumWidget_Release(pKEW
);
989 hr
= IWidget_QueryInterface(pWidget
, &IID_IDispatch
, (void **)&pDispatch
);
992 VariantInit(&vararg
[0]);
993 dispparams
.cNamedArgs
= 1;
994 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
995 dispparams
.cArgs
= 1;
996 dispparams
.rgvarg
= vararg
;
997 VariantInit(&varresult
);
998 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
999 ok_ole_success(hr
, IDispatch_Invoke
);
1000 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1001 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1002 excepinfo
.wCode
, excepinfo
.scode
);
1003 VariantClear(&varresult
);
1005 /* call put_Name (direct) */
1006 bstr
= SysAllocString(szSuperman
);
1007 hr
= IWidget_put_Name(pWidget
, bstr
);
1008 ok_ole_success(hr
, IWidget_put_Name
);
1009 SysFreeString(bstr
);
1012 dispparams
.cNamedArgs
= 0;
1013 dispparams
.rgdispidNamedArgs
= NULL
;
1014 dispparams
.cArgs
= 0;
1015 dispparams
.rgvarg
= NULL
;
1016 VariantInit(&varresult
);
1017 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1018 ok_ole_success(hr
, IDispatch_Invoke
);
1019 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1020 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1021 excepinfo
.wCode
, excepinfo
.scode
);
1022 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult
)));
1023 VariantClear(&varresult
);
1025 /* call get_Name (direct) */
1027 hr
= IWidget_get_Name(pWidget
, &bstr
);
1028 ok_ole_success(hr
, IWidget_get_Name
);
1029 ok(!lstrcmpW(bstr
, szCat
), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr
));
1030 SysFreeString(bstr
);
1032 /* call DoSomething */
1033 VariantInit(&vararg
[0]);
1034 VariantInit(&vararg
[1]);
1035 V_VT(&vararg
[1]) = VT_R8
;
1036 V_R8(&vararg
[1]) = 3.141;
1037 dispparams
.cNamedArgs
= 0;
1038 dispparams
.cArgs
= 2;
1039 dispparams
.rgdispidNamedArgs
= NULL
;
1040 dispparams
.rgvarg
= vararg
;
1041 VariantInit(&varresult
);
1042 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_DOSOMETHING
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1043 ok_ole_success(hr
, IDispatch_Invoke
);
1044 ok(V_VT(&varresult
) == VT_EMPTY
, "varresult should be VT_EMPTY\n");
1045 VariantClear(&varresult
);
1047 /* call get_State */
1048 dispparams
.cNamedArgs
= 0;
1049 dispparams
.cArgs
= 0;
1050 dispparams
.rgdispidNamedArgs
= NULL
;
1051 dispparams
.rgvarg
= NULL
;
1052 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1053 ok_ole_success(hr
, IDispatch_Invoke
);
1054 ok((V_VT(&varresult
) == VT_I4
) && (V_I4(&varresult
) == STATE_WIDGETIFIED
), "Return val mismatch\n");
1056 /* call get_State (direct) */
1057 hr
= IWidget_get_State(pWidget
, &the_state
);
1058 ok_ole_success(hr
, IWidget_get_state
);
1059 ok(the_state
== STATE_WIDGETIFIED
, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state
);
1061 /* call put_State */
1062 the_state
= STATE_WIDGETIFIED
;
1063 VariantInit(&vararg
[0]);
1064 V_VT(&vararg
[0]) = VT_BYREF
|VT_I4
;
1065 V_I4REF(&vararg
[0]) = (int *)&the_state
;
1066 dispparams
.cNamedArgs
= 1;
1067 dispparams
.cArgs
= 1;
1068 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1069 dispparams
.rgvarg
= vararg
;
1070 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1071 ok_ole_success(hr
, IDispatch_Invoke
);
1074 bstr
= SysAllocString(szTestTest
);
1075 VariantInit(&vararg
[0]);
1076 V_VT(&vararg
[0]) = VT_BYREF
|VT_BSTR
;
1077 V_BSTRREF(&vararg
[0]) = &bstr
;
1078 dispparams
.cNamedArgs
= 0;
1079 dispparams
.cArgs
= 1;
1080 dispparams
.rgdispidNamedArgs
= NULL
;
1081 dispparams
.rgvarg
= vararg
;
1082 VariantInit(&varresult
);
1083 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_MAP
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1084 ok_ole_success(hr
, IDispatch_Invoke
);
1085 ok(V_VT(&varresult
) == VT_BSTR
, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult
));
1086 ok(!lstrcmpW(V_BSTR(&varresult
), szTestTest
), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult
)));
1087 VariantClear(&varresult
);
1089 /* call SetOleColor with large negative VT_I4 param */
1090 VariantInit(&vararg
[0]);
1091 V_VT(&vararg
[0]) = VT_I4
;
1092 V_I4(&vararg
[0]) = 0x80000005;
1093 dispparams
.cNamedArgs
= 0;
1094 dispparams
.cArgs
= 1;
1095 dispparams
.rgdispidNamedArgs
= NULL
;
1096 dispparams
.rgvarg
= vararg
;
1097 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_SETOLECOLOR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, &excepinfo
, NULL
);
1098 ok_ole_success(hr
, IDispatch_Invoke
);
1100 /* call GetOleColor */
1101 dispparams
.cNamedArgs
= 0;
1102 dispparams
.cArgs
= 0;
1103 dispparams
.rgdispidNamedArgs
= NULL
;
1104 dispparams
.rgvarg
= NULL
;
1105 VariantInit(&varresult
);
1106 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_GETOLECOLOR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1107 ok_ole_success(hr
, IDispatch_Invoke
);
1108 VariantClear(&varresult
);
1110 /* call StructArgs (direct) */
1111 mystruct
= MYSTRUCT_BYPTR
;
1112 memcpy(mystructArray
, MYSTRUCT_ARRAY
, sizeof(mystructArray
));
1113 hr
= IWidget_StructArgs(pWidget
, MYSTRUCT_BYVAL
, &mystruct
, mystructArray
);
1115 ok_ole_success(hr
, IWidget_StructArgs
);
1119 dispparams
.cNamedArgs
= 0;
1120 dispparams
.cArgs
= 0;
1121 dispparams
.rgdispidNamedArgs
= NULL
;
1122 dispparams
.rgvarg
= NULL
;
1123 VariantInit(&varresult
);
1124 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1125 ok_ole_success(hr
, IDispatch_Invoke
);
1126 ok(V_VT(&varresult
) == VT_DISPATCH
, "vt %x\n", V_VT(&varresult
));
1127 VariantClear(&varresult
);
1129 /* call CloneInterface */
1130 dispparams
.cNamedArgs
= 0;
1131 dispparams
.cArgs
= 0;
1132 dispparams
.rgdispidNamedArgs
= NULL
;
1133 dispparams
.rgvarg
= NULL
;
1134 VariantInit(&varresult
);
1135 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONEINTERFACE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1136 ok_ole_success(hr
, IDispatch_Invoke
);
1137 ok(V_VT(&varresult
) == VT_DISPATCH
, "vt %x\n", V_VT(&varresult
));
1138 VariantClear(&varresult
);
1140 /* call CloneDispatch with automatic value getting */
1141 V_VT(&vararg
[0]) = VT_I2
;
1142 V_I2(&vararg
[0]) = 1;
1143 dispparams
.cNamedArgs
= 0;
1144 dispparams
.rgdispidNamedArgs
= NULL
;
1145 dispparams
.cArgs
= 1;
1146 dispparams
.rgvarg
= vararg
;
1147 VariantInit(&varresult
);
1148 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONEDISPATCH
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1149 ok_ole_success(hr
, IDispatch_Invoke
);
1151 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1152 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1153 excepinfo
.wCode
, excepinfo
.scode
);
1155 ok(V_VT(&varresult
) == VT_I2
, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult
));
1156 ok(V_I2(&varresult
) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult
));
1157 VariantClear(&varresult
);
1159 /* call CloneCoclass */
1160 dispparams
.cNamedArgs
= 0;
1161 dispparams
.cArgs
= 0;
1162 dispparams
.rgdispidNamedArgs
= NULL
;
1163 dispparams
.rgvarg
= NULL
;
1164 VariantInit(&varresult
);
1165 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONECOCLASS
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1166 ok_ole_success(hr
, IDispatch_Invoke
);
1168 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1169 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1170 excepinfo
.wCode
, excepinfo
.scode
);
1172 ok(V_VT(&varresult
) == VT_DISPATCH
, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult
));
1173 ok(!V_DISPATCH(&varresult
), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult
));
1174 VariantClear(&varresult
);
1176 /* call Value with a VT_VARIANT|VT_BYREF type */
1177 V_VT(&vararg
[0]) = VT_VARIANT
|VT_BYREF
;
1178 V_VARIANTREF(&vararg
[0]) = &vararg
[1];
1179 V_VT(&vararg
[1]) = VT_I2
;
1180 V_I2(&vararg
[1]) = 1;
1181 dispparams
.cNamedArgs
= 0;
1182 dispparams
.rgdispidNamedArgs
= NULL
;
1183 dispparams
.cArgs
= 1;
1184 dispparams
.rgvarg
= vararg
;
1185 VariantInit(&varresult
);
1186 hr
= IDispatch_Invoke(pDispatch
, DISPID_VALUE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1187 ok_ole_success(hr
, IDispatch_Invoke
);
1189 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1190 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1191 excepinfo
.wCode
, excepinfo
.scode
);
1193 ok(V_VT(&varresult
) == VT_I2
, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult
));
1194 ok(V_I2(&varresult
) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult
));
1195 VariantClear(&varresult
);
1197 /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1198 * handling of void return types */
1199 /* use a big type to ensure that the variant was properly copied into the
1200 * destination function's args */
1201 V_VT(&vararg
[0]) = VT_CY
;
1202 S(V_CY(&vararg
[0])).Hi
= 0xdababe;
1203 S(V_CY(&vararg
[0])).Lo
= 0xdeadbeef;
1204 dispparams
.cNamedArgs
= 0;
1205 dispparams
.cArgs
= 1;
1206 dispparams
.rgdispidNamedArgs
= NULL
;
1207 dispparams
.rgvarg
= vararg
;
1208 VariantInit(&varresult
);
1209 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARIANT
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1210 ok_ole_success(hr
, IDispatch_Invoke
);
1211 VariantClear(&varresult
);
1214 VariantInit(&vararg
[3]);
1215 V_VT(&vararg
[3]) = VT_I4
;
1216 V_I4(&vararg
[3]) = 3;
1217 VariantInit(&vararg
[2]);
1218 V_VT(&vararg
[2]) = VT_I4
;
1219 V_I4(&vararg
[2]) = 0;
1220 VariantInit(&vararg
[1]);
1221 V_VT(&vararg
[1]) = VT_I4
;
1222 V_I4(&vararg
[1]) = 1;
1223 VariantInit(&vararg
[0]);
1224 V_VT(&vararg
[0]) = VT_I4
;
1225 V_I4(&vararg
[0]) = 2;
1226 dispparams
.cNamedArgs
= 0;
1227 dispparams
.cArgs
= 4;
1228 dispparams
.rgdispidNamedArgs
= NULL
;
1229 dispparams
.rgvarg
= vararg
;
1230 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARARG
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1231 ok_ole_success(hr
, ITypeInfo_Invoke
);
1233 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1235 dispparams
.cNamedArgs
= 1;
1236 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1237 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARARG
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1238 ok(hr
== DISP_E_NONAMEDARGS
, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr
);
1239 dispidNamed
= DISPID_PROPERTYPUT
;
1242 dispparams
.cNamedArgs
= 0;
1243 dispparams
.cArgs
= 0;
1244 dispparams
.rgdispidNamedArgs
= NULL
;
1245 dispparams
.rgvarg
= NULL
;
1246 VariantInit(&varresult
);
1247 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_ERROR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, &excepinfo
, NULL
);
1248 ok(hr
== DISP_E_EXCEPTION
, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr
);
1249 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== E_NOTIMPL
,
1250 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1251 excepinfo
.wCode
, excepinfo
.scode
);
1252 VariantClear(&varresult
);
1255 pTypeInfo
= NonOleAutomation_GetTypeInfo();
1256 dispparams
.cNamedArgs
= 0;
1257 dispparams
.cArgs
= 0;
1258 dispparams
.rgdispidNamedArgs
= NULL
;
1259 dispparams
.rgvarg
= NULL
;
1260 VariantInit(&varresult
);
1261 hr
= ITypeInfo_Invoke(pTypeInfo
, &NonOleAutomation
, DISPID_NOA_BSTRRET
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1262 ok_ole_success(hr
, ITypeInfo_Invoke
);
1263 ok(V_VT(&varresult
) == VT_BSTR
, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult
));
1264 ok(V_BSTR(&varresult
) != NULL
, "V_BSTR(&varresult) should not be NULL\n");
1266 VariantClear(&varresult
);
1267 ITypeInfo_Release(pTypeInfo
);
1269 /* tests call put_Name without named arg */
1270 VariantInit(&vararg
[0]);
1271 dispparams
.cNamedArgs
= 0;
1272 dispparams
.rgdispidNamedArgs
= NULL
;
1273 dispparams
.cArgs
= 1;
1274 dispparams
.rgvarg
= vararg
;
1275 VariantInit(&varresult
);
1276 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1277 ok(hr
== DISP_E_PARAMNOTFOUND
, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr
);
1278 VariantClear(&varresult
);
1280 /* tests param type that cannot be coerced */
1281 VariantInit(&vararg
[0]);
1282 V_VT(&vararg
[0]) = VT_UNKNOWN
;
1283 V_UNKNOWN(&vararg
[0]) = NULL
;
1284 dispparams
.cNamedArgs
= 1;
1285 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1286 dispparams
.cArgs
= 1;
1287 dispparams
.rgvarg
= vararg
;
1288 VariantInit(&varresult
);
1289 #if 0 /* NULL unknown not currently marshaled correctly */
1290 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1291 ok(hr
== DISP_E_TYPEMISMATCH
, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr
);
1293 VariantClear(&varresult
);
1295 /* tests bad param type */
1296 VariantInit(&vararg
[0]);
1297 V_VT(&vararg
[0]) = VT_CLSID
;
1298 V_BYREF(&vararg
[0]) = NULL
;
1299 dispparams
.cNamedArgs
= 1;
1300 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1301 dispparams
.cArgs
= 1;
1302 dispparams
.rgvarg
= vararg
;
1303 VariantInit(&varresult
);
1304 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1305 ok(hr
== DISP_E_BADVARTYPE
, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr
);
1306 VariantClear(&varresult
);
1308 /* tests too small param count */
1309 dispparams
.cNamedArgs
= 0;
1310 dispparams
.rgdispidNamedArgs
= NULL
;
1311 dispparams
.cArgs
= 0;
1312 dispparams
.rgvarg
= NULL
;
1313 VariantInit(&varresult
);
1314 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_DOSOMETHING
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1315 ok(hr
== DISP_E_BADPARAMCOUNT
, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr
);
1316 VariantClear(&varresult
);
1318 /* tests propget function with large param count */
1319 VariantInit(&vararg
[0]);
1320 V_VT(&vararg
[0]) = VT_BSTR
;
1321 V_BSTR(&vararg
[0]) = NULL
;
1322 V_VT(&vararg
[1]) = VT_I4
;
1323 V_I4(&vararg
[1]) = 1;
1324 dispparams
.cNamedArgs
= 0;
1325 dispparams
.cArgs
= 2;
1326 dispparams
.rgdispidNamedArgs
= NULL
;
1327 dispparams
.rgvarg
= vararg
;
1328 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1329 ok(hr
== DISP_E_NOTACOLLECTION
, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr
);
1331 IDispatch_Release(pDispatch
);
1332 IWidget_Release(pWidget
);
1334 trace("calling end_host_object\n");
1335 end_host_object(tid
, thread
);
1338 static void test_DispCallFunc(void)
1340 static const WCHAR szEmpty
[] = { 0 };
1341 VARTYPE rgvt
[] = { VT_R8
, VT_BSTR
, VT_BSTR
, VT_VARIANT
|VT_BYREF
};
1342 VARIANTARG vararg
[4];
1344 VARIANTARG
*rgpvarg
[4] = { &vararg
[0], &vararg
[1], &vararg
[2], &vararg
[3] };
1345 VARIANTARG varresult
;
1347 IWidget
*pWidget
= Widget_Create();
1348 V_VT(&vararg
[0]) = VT_R8
;
1349 V_R8(&vararg
[0]) = 3.141;
1350 V_VT(&vararg
[1]) = VT_BSTR
;
1351 V_BSTR(&vararg
[1]) = SysAllocString(szEmpty
);
1352 V_VT(&vararg
[2]) = VT_BSTR
;
1353 V_BSTR(&vararg
[2]) = SysAllocString(szEmpty
);
1354 V_VT(&vararg
[3]) = VT_VARIANT
|VT_BYREF
;
1355 V_VARIANTREF(&vararg
[3]) = &varref
;
1356 V_VT(&varref
) = VT_ERROR
;
1357 V_ERROR(&varref
) = DISP_E_PARAMNOTFOUND
;
1358 VariantInit(&varresult
);
1359 hr
= DispCallFunc(pWidget
, 9*sizeof(void*), CC_STDCALL
, VT_UI4
, 4, rgvt
, rgpvarg
, &varresult
);
1360 ok_ole_success(hr
, DispCallFunc
);
1361 VariantClear(&varresult
);
1362 VariantClear(&vararg
[1]);
1363 VariantClear(&vararg
[2]);
1364 IWidget_Release(pWidget
);
1367 static void test_StaticWidget(void)
1369 ITypeInfo
*type_info
;
1370 DISPPARAMS dispparams
;
1371 VARIANTARG vararg
[4];
1372 EXCEPINFO excepinfo
;
1376 type_info
= get_type_info(&IID_IStaticWidget
);
1379 dispparams
.cNamedArgs
= 0;
1380 dispparams
.cArgs
= 1;
1381 dispparams
.rgdispidNamedArgs
= NULL
;
1382 dispparams
.rgvarg
= vararg
;
1383 V_VT(vararg
) = VT_DISPATCH
;
1384 V_DISPATCH(vararg
) = (IDispatch
*)&TestDualDisp
;
1385 VariantInit(&varresult
);
1386 hr
= ITypeInfo_Invoke(type_info
, &StaticWidget
, DISPID_TM_TESTDUAL
, DISPATCH_METHOD
,
1387 &dispparams
, &varresult
, &excepinfo
, NULL
);
1388 ok_ole_success(hr
, IDispatch_Invoke
);
1389 ok(V_VT(&varresult
) == VT_EMPTY
, "vt %x\n", V_VT(&varresult
));
1390 VariantClear(&varresult
);
1392 ITypeInfo_Release(type_info
);
1395 START_TEST(tmarshal
)
1399 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
1401 hr
= register_current_module_typelib();
1402 ok_ole_success(hr
, register_current_module_typelib
);
1404 test_typelibmarshal();
1405 test_DispCallFunc();
1406 test_StaticWidget();
1408 hr
= UnRegisterTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
,
1409 sizeof(void*) == 8 ? SYS_WIN64
: SYS_WIN32
);
1410 ok_ole_success(hr
, UnRegisterTypeLib
);