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 HRESULT WINAPI
Widget_put_prop_with_lcid(
628 IWidget
* iface
, LONG lcid
, INT i
)
630 trace("put_prop_with_lcid(%08x, %x)\n", lcid
, i
);
631 ok(lcid
== MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), "got lcid %08x\n", lcid
);
632 ok(i
== 0xcafe, "got %08x\n", i
);
636 static HRESULT WINAPI
Widget_get_prop_with_lcid(
637 IWidget
* iface
, LONG lcid
, INT
*i
)
639 trace("get_prop_with_lcid(%08x, %p)\n", lcid
, i
);
640 ok(lcid
== MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), "got lcid %08x\n", lcid
);
645 static const struct IWidgetVtbl Widget_VTable
=
647 Widget_QueryInterface
,
650 Widget_GetTypeInfoCount
,
652 Widget_GetIDsOfNames
,
663 Widget_CloneDispatch
,
667 Widget_VariantArrayPtr
,
672 Widget_CloneInterface
,
673 Widget_put_prop_with_lcid
,
674 Widget_get_prop_with_lcid
677 static HRESULT WINAPI
StaticWidget_QueryInterface(IStaticWidget
*iface
, REFIID riid
, void **ppvObject
)
679 if (IsEqualIID(riid
, &IID_IStaticWidget
) || IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IDispatch
))
681 IStaticWidget_AddRef(iface
);
687 return E_NOINTERFACE
;
690 static ULONG WINAPI
StaticWidget_AddRef(IStaticWidget
*iface
)
695 static ULONG WINAPI
StaticWidget_Release(IStaticWidget
*iface
)
700 static HRESULT WINAPI
StaticWidget_GetTypeInfoCount(IStaticWidget
*iface
, UINT
*pctinfo
)
702 ok(0, "unexpected call\n");
706 static HRESULT WINAPI
StaticWidget_GetTypeInfo(IStaticWidget
*iface
, UINT iTInfo
, LCID lcid
,
709 ok(0, "unexpected call\n");
713 static HRESULT WINAPI
StaticWidget_GetIDsOfNames(IStaticWidget
*iface
, REFIID riid
, LPOLESTR
*rgszNames
,
714 UINT cNames
, LCID lcid
, DISPID
*rgDispId
)
716 ok(0, "unexpected call\n");
720 static HRESULT WINAPI
StaticWidget_Invoke(IStaticWidget
*iface
, DISPID dispIdMember
, REFIID riid
,
721 LCID lcid
, WORD wFlags
, DISPPARAMS
*pDispParams
, VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
,
724 ok(0, "unexpected call\n");
728 static HRESULT WINAPI
StaticWidget_TestDual(IStaticWidget
*iface
, ItestDual
*p
)
730 trace("TestDual()\n");
732 ok(p
== &TestDual
, "wrong ItestDual\n");
736 static const IStaticWidgetVtbl StaticWidgetVtbl
= {
737 StaticWidget_QueryInterface
,
739 StaticWidget_Release
,
740 StaticWidget_GetTypeInfoCount
,
741 StaticWidget_GetTypeInfo
,
742 StaticWidget_GetIDsOfNames
,
744 StaticWidget_TestDual
747 static IStaticWidget StaticWidget
= { &StaticWidgetVtbl
};
749 typedef struct KindaEnum
751 const IKindaEnumWidgetVtbl
*lpVtbl
;
755 static HRESULT
register_current_module_typelib(void)
757 WCHAR path
[MAX_PATH
];
758 CHAR pathA
[MAX_PATH
];
762 GetModuleFileNameA(NULL
, pathA
, MAX_PATH
);
763 MultiByteToWideChar(CP_ACP
, 0, pathA
, -1, path
, MAX_PATH
);
765 hr
= LoadTypeLib(path
, &typelib
);
768 hr
= RegisterTypeLib(typelib
, path
, NULL
);
769 ITypeLib_Release(typelib
);
774 static ITypeInfo
*get_type_info(REFIID riid
)
776 ITypeInfo
*pTypeInfo
;
780 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
781 ok_ole_success(hr
, LoadRegTypeLib
);
785 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, riid
, &pTypeInfo
);
786 ITypeLib_Release(pTypeLib
);
787 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
794 static IWidget
*Widget_Create(void)
797 ITypeInfo
*pTypeInfo
;
800 pTypeInfo
= get_type_info(&IID_IWidget
);
804 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
805 This
->lpVtbl
= &Widget_VTable
;
807 This
->pDispatchUnknown
= NULL
;
809 hr
= CreateStdDispatch((IUnknown
*)&This
->lpVtbl
, This
, pTypeInfo
, &This
->pDispatchUnknown
);
810 ok_ole_success(hr
, CreateStdDispatch
);
811 ITypeInfo_Release(pTypeInfo
);
814 return (IWidget
*)&This
->lpVtbl
;
817 HeapFree(GetProcessHeap(), 0, This
);
822 static HRESULT WINAPI
KindaEnum_QueryInterface(
823 IKindaEnumWidget
*iface
,
824 /* [in] */ REFIID riid
,
825 /* [iid_is][out] */ void __RPC_FAR
*__RPC_FAR
*ppvObject
)
827 if (IsEqualIID(riid
, &IID_IKindaEnumWidget
) || IsEqualIID(riid
, &IID_IUnknown
))
829 IKindaEnumWidget_AddRef(iface
);
836 return E_NOINTERFACE
;
840 static ULONG WINAPI
KindaEnum_AddRef(
841 IKindaEnumWidget
*iface
)
843 KindaEnum
*This
= (KindaEnum
*)iface
;
845 return InterlockedIncrement(&This
->refs
);
848 static ULONG WINAPI
KindaEnum_Release(
849 IKindaEnumWidget
*iface
)
851 KindaEnum
*This
= (KindaEnum
*)iface
;
852 ULONG refs
= InterlockedDecrement(&This
->refs
);
855 memset(This
, 0xcc, sizeof(*This
));
856 HeapFree(GetProcessHeap(), 0, This
);
857 trace("KindaEnumWidget destroyed!\n");
863 static HRESULT WINAPI
KindaEnum_Next(
864 IKindaEnumWidget
*iface
,
865 /* [out] */ IWidget __RPC_FAR
*__RPC_FAR
*widget
)
867 *widget
= Widget_Create();
871 return E_OUTOFMEMORY
;
874 static HRESULT WINAPI
KindaEnum_Count(
875 IKindaEnumWidget
*iface
,
876 /* [out] */ ULONG __RPC_FAR
*count
)
881 static HRESULT WINAPI
KindaEnum_Reset(
882 IKindaEnumWidget
*iface
)
887 static HRESULT WINAPI
KindaEnum_Clone(
888 IKindaEnumWidget
*iface
,
889 /* [out] */ IKindaEnumWidget __RPC_FAR
*__RPC_FAR
*ppenum
)
894 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable
=
896 KindaEnum_QueryInterface
,
905 static IKindaEnumWidget
*KindaEnumWidget_Create(void)
909 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
910 if (!This
) return NULL
;
911 This
->lpVtbl
= &KindaEnumWidget_VTable
;
913 return (IKindaEnumWidget
*)This
;
916 static HRESULT WINAPI
NonOleAutomation_QueryInterface(INonOleAutomation
*iface
, REFIID riid
, void **ppv
)
918 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_INonOleAutomation
))
920 *(INonOleAutomation
**)ppv
= iface
;
924 return E_NOINTERFACE
;
927 static ULONG WINAPI
NonOleAutomation_AddRef(INonOleAutomation
*iface
)
932 static ULONG WINAPI
NonOleAutomation_Release(INonOleAutomation
*iface
)
937 static BSTR WINAPI
NonOleAutomation_BstrRet(INonOleAutomation
*iface
)
939 static const WCHAR wszTestString
[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
940 return SysAllocString(wszTestString
);
943 static INonOleAutomationVtbl NonOleAutomation_VTable
=
945 NonOleAutomation_QueryInterface
,
946 NonOleAutomation_AddRef
,
947 NonOleAutomation_Release
,
948 NonOleAutomation_BstrRet
,
951 static INonOleAutomation NonOleAutomation
= { &NonOleAutomation_VTable
};
953 static ITypeInfo
*NonOleAutomation_GetTypeInfo(void)
956 HRESULT hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &pTypeLib
);
957 ok_ole_success(hr
, LoadRegTypeLib
);
960 ITypeInfo
*pTypeInfo
;
961 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_INonOleAutomation
, &pTypeInfo
);
962 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
968 static void test_typelibmarshal(void)
970 static const WCHAR szCat
[] = { 'C','a','t',0 };
971 static const WCHAR szTestTest
[] = { 'T','e','s','t','T','e','s','t',0 };
972 static WCHAR szSuperman
[] = { 'S','u','p','e','r','m','a','n',0 };
974 IKindaEnumWidget
*pKEW
= KindaEnumWidget_Create();
977 IDispatch
*pDispatch
;
978 static const LARGE_INTEGER ullZero
;
981 DISPID dispidNamed
= DISPID_PROPERTYPUT
;
982 DISPPARAMS dispparams
;
983 VARIANTARG vararg
[4];
988 ITypeInfo
*pTypeInfo
;
990 MYSTRUCT mystructArray
[5];
992 ok(pKEW
!= NULL
, "Widget creation failed\n");
994 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
995 ok_ole_success(hr
, CreateStreamOnHGlobal
);
996 tid
= start_host_object(pStream
, &IID_IKindaEnumWidget
, (IUnknown
*)pKEW
, MSHLFLAGS_NORMAL
, &thread
);
997 IKindaEnumWidget_Release(pKEW
);
999 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1000 hr
= CoUnmarshalInterface(pStream
, &IID_IKindaEnumWidget
, (void **)&pKEW
);
1001 ok_ole_success(hr
, CoUnmarshalInterface
);
1002 IStream_Release(pStream
);
1004 hr
= IKindaEnumWidget_Next(pKEW
, &pWidget
);
1005 ok_ole_success(hr
, IKindaEnumWidget_Next
);
1007 IKindaEnumWidget_Release(pKEW
);
1009 hr
= IWidget_QueryInterface(pWidget
, &IID_IDispatch
, (void **)&pDispatch
);
1012 VariantInit(&vararg
[0]);
1013 dispparams
.cNamedArgs
= 1;
1014 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1015 dispparams
.cArgs
= 1;
1016 dispparams
.rgvarg
= vararg
;
1017 VariantInit(&varresult
);
1018 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1019 ok_ole_success(hr
, IDispatch_Invoke
);
1020 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1021 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1022 excepinfo
.wCode
, excepinfo
.scode
);
1023 VariantClear(&varresult
);
1025 /* call put_Name (direct) */
1026 bstr
= SysAllocString(szSuperman
);
1027 hr
= IWidget_put_Name(pWidget
, bstr
);
1028 ok_ole_success(hr
, IWidget_put_Name
);
1029 SysFreeString(bstr
);
1032 dispparams
.cNamedArgs
= 0;
1033 dispparams
.rgdispidNamedArgs
= NULL
;
1034 dispparams
.cArgs
= 0;
1035 dispparams
.rgvarg
= NULL
;
1036 VariantInit(&varresult
);
1037 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1038 ok_ole_success(hr
, IDispatch_Invoke
);
1039 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1040 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1041 excepinfo
.wCode
, excepinfo
.scode
);
1042 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult
)));
1043 VariantClear(&varresult
);
1045 /* call get_Name (direct) */
1047 hr
= IWidget_get_Name(pWidget
, &bstr
);
1048 ok_ole_success(hr
, IWidget_get_Name
);
1049 ok(!lstrcmpW(bstr
, szCat
), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr
));
1050 SysFreeString(bstr
);
1052 /* call DoSomething */
1053 VariantInit(&vararg
[0]);
1054 VariantInit(&vararg
[1]);
1055 V_VT(&vararg
[1]) = VT_R8
;
1056 V_R8(&vararg
[1]) = 3.141;
1057 dispparams
.cNamedArgs
= 0;
1058 dispparams
.cArgs
= 2;
1059 dispparams
.rgdispidNamedArgs
= NULL
;
1060 dispparams
.rgvarg
= vararg
;
1061 VariantInit(&varresult
);
1062 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_DOSOMETHING
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1063 ok_ole_success(hr
, IDispatch_Invoke
);
1064 ok(V_VT(&varresult
) == VT_EMPTY
, "varresult should be VT_EMPTY\n");
1065 VariantClear(&varresult
);
1067 /* call get_State */
1068 dispparams
.cNamedArgs
= 0;
1069 dispparams
.cArgs
= 0;
1070 dispparams
.rgdispidNamedArgs
= NULL
;
1071 dispparams
.rgvarg
= NULL
;
1072 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1073 ok_ole_success(hr
, IDispatch_Invoke
);
1074 ok((V_VT(&varresult
) == VT_I4
) && (V_I4(&varresult
) == STATE_WIDGETIFIED
), "Return val mismatch\n");
1076 /* call get_State (direct) */
1077 hr
= IWidget_get_State(pWidget
, &the_state
);
1078 ok_ole_success(hr
, IWidget_get_state
);
1079 ok(the_state
== STATE_WIDGETIFIED
, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state
);
1081 /* call put_State */
1082 the_state
= STATE_WIDGETIFIED
;
1083 VariantInit(&vararg
[0]);
1084 V_VT(&vararg
[0]) = VT_BYREF
|VT_I4
;
1085 V_I4REF(&vararg
[0]) = (int *)&the_state
;
1086 dispparams
.cNamedArgs
= 1;
1087 dispparams
.cArgs
= 1;
1088 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1089 dispparams
.rgvarg
= vararg
;
1090 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1091 ok_ole_success(hr
, IDispatch_Invoke
);
1094 bstr
= SysAllocString(szTestTest
);
1095 VariantInit(&vararg
[0]);
1096 V_VT(&vararg
[0]) = VT_BYREF
|VT_BSTR
;
1097 V_BSTRREF(&vararg
[0]) = &bstr
;
1098 dispparams
.cNamedArgs
= 0;
1099 dispparams
.cArgs
= 1;
1100 dispparams
.rgdispidNamedArgs
= NULL
;
1101 dispparams
.rgvarg
= vararg
;
1102 VariantInit(&varresult
);
1103 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_MAP
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1104 ok_ole_success(hr
, IDispatch_Invoke
);
1105 ok(V_VT(&varresult
) == VT_BSTR
, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult
));
1106 ok(!lstrcmpW(V_BSTR(&varresult
), szTestTest
), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult
)));
1107 VariantClear(&varresult
);
1109 /* call SetOleColor with large negative VT_I4 param */
1110 VariantInit(&vararg
[0]);
1111 V_VT(&vararg
[0]) = VT_I4
;
1112 V_I4(&vararg
[0]) = 0x80000005;
1113 dispparams
.cNamedArgs
= 0;
1114 dispparams
.cArgs
= 1;
1115 dispparams
.rgdispidNamedArgs
= NULL
;
1116 dispparams
.rgvarg
= vararg
;
1117 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_SETOLECOLOR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, &excepinfo
, NULL
);
1118 ok_ole_success(hr
, IDispatch_Invoke
);
1120 /* call GetOleColor */
1121 dispparams
.cNamedArgs
= 0;
1122 dispparams
.cArgs
= 0;
1123 dispparams
.rgdispidNamedArgs
= NULL
;
1124 dispparams
.rgvarg
= NULL
;
1125 VariantInit(&varresult
);
1126 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_GETOLECOLOR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1127 ok_ole_success(hr
, IDispatch_Invoke
);
1128 VariantClear(&varresult
);
1130 /* call StructArgs (direct) */
1131 mystruct
= MYSTRUCT_BYPTR
;
1132 memcpy(mystructArray
, MYSTRUCT_ARRAY
, sizeof(mystructArray
));
1133 hr
= IWidget_StructArgs(pWidget
, MYSTRUCT_BYVAL
, &mystruct
, mystructArray
);
1135 ok_ole_success(hr
, IWidget_StructArgs
);
1139 dispparams
.cNamedArgs
= 0;
1140 dispparams
.cArgs
= 0;
1141 dispparams
.rgdispidNamedArgs
= NULL
;
1142 dispparams
.rgvarg
= NULL
;
1143 VariantInit(&varresult
);
1144 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1145 ok_ole_success(hr
, IDispatch_Invoke
);
1146 ok(V_VT(&varresult
) == VT_DISPATCH
, "vt %x\n", V_VT(&varresult
));
1147 VariantClear(&varresult
);
1149 /* call CloneInterface */
1150 dispparams
.cNamedArgs
= 0;
1151 dispparams
.cArgs
= 0;
1152 dispparams
.rgdispidNamedArgs
= NULL
;
1153 dispparams
.rgvarg
= NULL
;
1154 VariantInit(&varresult
);
1155 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONEINTERFACE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1156 ok_ole_success(hr
, IDispatch_Invoke
);
1157 ok(V_VT(&varresult
) == VT_DISPATCH
, "vt %x\n", V_VT(&varresult
));
1158 VariantClear(&varresult
);
1160 /* call CloneDispatch with automatic value getting */
1161 V_VT(&vararg
[0]) = VT_I2
;
1162 V_I2(&vararg
[0]) = 1;
1163 dispparams
.cNamedArgs
= 0;
1164 dispparams
.rgdispidNamedArgs
= NULL
;
1165 dispparams
.cArgs
= 1;
1166 dispparams
.rgvarg
= vararg
;
1167 VariantInit(&varresult
);
1168 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONEDISPATCH
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1169 ok_ole_success(hr
, IDispatch_Invoke
);
1171 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1172 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1173 excepinfo
.wCode
, excepinfo
.scode
);
1175 ok(V_VT(&varresult
) == VT_I2
, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult
));
1176 ok(V_I2(&varresult
) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult
));
1177 VariantClear(&varresult
);
1179 /* call CloneCoclass */
1180 dispparams
.cNamedArgs
= 0;
1181 dispparams
.cArgs
= 0;
1182 dispparams
.rgdispidNamedArgs
= NULL
;
1183 dispparams
.rgvarg
= NULL
;
1184 VariantInit(&varresult
);
1185 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_CLONECOCLASS
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1186 ok_ole_success(hr
, IDispatch_Invoke
);
1188 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1189 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1190 excepinfo
.wCode
, excepinfo
.scode
);
1192 ok(V_VT(&varresult
) == VT_DISPATCH
, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult
));
1193 ok(!V_DISPATCH(&varresult
), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult
));
1194 VariantClear(&varresult
);
1196 /* call Value with a VT_VARIANT|VT_BYREF type */
1197 V_VT(&vararg
[0]) = VT_VARIANT
|VT_BYREF
;
1198 V_VARIANTREF(&vararg
[0]) = &vararg
[1];
1199 V_VT(&vararg
[1]) = VT_I2
;
1200 V_I2(&vararg
[1]) = 1;
1201 dispparams
.cNamedArgs
= 0;
1202 dispparams
.rgdispidNamedArgs
= NULL
;
1203 dispparams
.cArgs
= 1;
1204 dispparams
.rgvarg
= vararg
;
1205 VariantInit(&varresult
);
1206 hr
= IDispatch_Invoke(pDispatch
, DISPID_VALUE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1207 ok_ole_success(hr
, IDispatch_Invoke
);
1209 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== S_OK
,
1210 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1211 excepinfo
.wCode
, excepinfo
.scode
);
1213 ok(V_VT(&varresult
) == VT_I2
, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult
));
1214 ok(V_I2(&varresult
) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult
));
1215 VariantClear(&varresult
);
1217 /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1218 * handling of void return types */
1219 /* use a big type to ensure that the variant was properly copied into the
1220 * destination function's args */
1221 V_VT(&vararg
[0]) = VT_CY
;
1222 S(V_CY(&vararg
[0])).Hi
= 0xdababe;
1223 S(V_CY(&vararg
[0])).Lo
= 0xdeadbeef;
1224 dispparams
.cNamedArgs
= 0;
1225 dispparams
.cArgs
= 1;
1226 dispparams
.rgdispidNamedArgs
= NULL
;
1227 dispparams
.rgvarg
= vararg
;
1228 VariantInit(&varresult
);
1229 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARIANT
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1230 ok_ole_success(hr
, IDispatch_Invoke
);
1231 VariantClear(&varresult
);
1234 VariantInit(&vararg
[3]);
1235 V_VT(&vararg
[3]) = VT_I4
;
1236 V_I4(&vararg
[3]) = 3;
1237 VariantInit(&vararg
[2]);
1238 V_VT(&vararg
[2]) = VT_I4
;
1239 V_I4(&vararg
[2]) = 0;
1240 VariantInit(&vararg
[1]);
1241 V_VT(&vararg
[1]) = VT_I4
;
1242 V_I4(&vararg
[1]) = 1;
1243 VariantInit(&vararg
[0]);
1244 V_VT(&vararg
[0]) = VT_I4
;
1245 V_I4(&vararg
[0]) = 2;
1246 dispparams
.cNamedArgs
= 0;
1247 dispparams
.cArgs
= 4;
1248 dispparams
.rgdispidNamedArgs
= NULL
;
1249 dispparams
.rgvarg
= vararg
;
1250 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARARG
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1251 ok_ole_success(hr
, ITypeInfo_Invoke
);
1253 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1255 dispparams
.cNamedArgs
= 1;
1256 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1257 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_VARARG
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1258 ok(hr
== DISP_E_NONAMEDARGS
, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr
);
1259 dispidNamed
= DISPID_PROPERTYPUT
;
1262 dispparams
.cNamedArgs
= 0;
1263 dispparams
.cArgs
= 0;
1264 dispparams
.rgdispidNamedArgs
= NULL
;
1265 dispparams
.rgvarg
= NULL
;
1266 VariantInit(&varresult
);
1267 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_ERROR
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, NULL
, &excepinfo
, NULL
);
1268 ok(hr
== DISP_E_EXCEPTION
, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr
);
1269 ok(excepinfo
.wCode
== 0x0 && excepinfo
.scode
== E_NOTIMPL
,
1270 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1271 excepinfo
.wCode
, excepinfo
.scode
);
1272 VariantClear(&varresult
);
1275 pTypeInfo
= NonOleAutomation_GetTypeInfo();
1276 dispparams
.cNamedArgs
= 0;
1277 dispparams
.cArgs
= 0;
1278 dispparams
.rgdispidNamedArgs
= NULL
;
1279 dispparams
.rgvarg
= NULL
;
1280 VariantInit(&varresult
);
1281 hr
= ITypeInfo_Invoke(pTypeInfo
, &NonOleAutomation
, DISPID_NOA_BSTRRET
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1282 ok_ole_success(hr
, ITypeInfo_Invoke
);
1283 ok(V_VT(&varresult
) == VT_BSTR
, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult
));
1284 ok(V_BSTR(&varresult
) != NULL
, "V_BSTR(&varresult) should not be NULL\n");
1286 VariantClear(&varresult
);
1287 ITypeInfo_Release(pTypeInfo
);
1289 /* tests call put_Name without named arg */
1290 VariantInit(&vararg
[0]);
1291 dispparams
.cNamedArgs
= 0;
1292 dispparams
.rgdispidNamedArgs
= NULL
;
1293 dispparams
.cArgs
= 1;
1294 dispparams
.rgvarg
= vararg
;
1295 VariantInit(&varresult
);
1296 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1297 ok(hr
== DISP_E_PARAMNOTFOUND
, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr
);
1298 VariantClear(&varresult
);
1300 /* tests param type that cannot be coerced */
1301 VariantInit(&vararg
[0]);
1302 V_VT(&vararg
[0]) = VT_UNKNOWN
;
1303 V_UNKNOWN(&vararg
[0]) = NULL
;
1304 dispparams
.cNamedArgs
= 1;
1305 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1306 dispparams
.cArgs
= 1;
1307 dispparams
.rgvarg
= vararg
;
1308 VariantInit(&varresult
);
1309 #if 0 /* NULL unknown not currently marshaled correctly */
1310 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1311 ok(hr
== DISP_E_TYPEMISMATCH
, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr
);
1313 VariantClear(&varresult
);
1315 /* tests bad param type */
1316 VariantInit(&vararg
[0]);
1317 V_VT(&vararg
[0]) = VT_CLSID
;
1318 V_BYREF(&vararg
[0]) = NULL
;
1319 dispparams
.cNamedArgs
= 1;
1320 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1321 dispparams
.cArgs
= 1;
1322 dispparams
.rgvarg
= vararg
;
1323 VariantInit(&varresult
);
1324 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_NAME
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1325 ok(hr
== DISP_E_BADVARTYPE
, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr
);
1326 VariantClear(&varresult
);
1328 /* tests too small param count */
1329 dispparams
.cNamedArgs
= 0;
1330 dispparams
.rgdispidNamedArgs
= NULL
;
1331 dispparams
.cArgs
= 0;
1332 dispparams
.rgvarg
= NULL
;
1333 VariantInit(&varresult
);
1334 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_DOSOMETHING
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_METHOD
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1335 ok(hr
== DISP_E_BADPARAMCOUNT
, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr
);
1336 VariantClear(&varresult
);
1338 /* tests propget function with large param count */
1339 VariantInit(&vararg
[0]);
1340 V_VT(&vararg
[0]) = VT_BSTR
;
1341 V_BSTR(&vararg
[0]) = NULL
;
1342 V_VT(&vararg
[1]) = VT_I4
;
1343 V_I4(&vararg
[1]) = 1;
1344 dispparams
.cNamedArgs
= 0;
1345 dispparams
.cArgs
= 2;
1346 dispparams
.rgdispidNamedArgs
= NULL
;
1347 dispparams
.rgvarg
= vararg
;
1348 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_STATE
, &IID_NULL
, LOCALE_NEUTRAL
, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1349 ok(hr
== DISP_E_NOTACOLLECTION
, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr
);
1351 /* test propput with lcid */
1353 /* the lcid passed to the function is the first lcid in the typelib header.
1354 Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1355 VariantInit(&vararg
[0]);
1356 V_VT(&vararg
[0]) = VT_I4
;
1357 V_I4(&vararg
[0]) = 0xcafe;
1358 dispparams
.cNamedArgs
= 1;
1359 dispparams
.rgdispidNamedArgs
= &dispidNamed
;
1360 dispparams
.cArgs
= 1;
1361 dispparams
.rgvarg
= vararg
;
1362 VariantInit(&varresult
);
1363 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_PROP_WITH_LCID
, &IID_NULL
, 0x40c, DISPATCH_PROPERTYPUT
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1365 ok_ole_success(hr
, ITypeInfo_Invoke
);
1366 VariantClear(&varresult
);
1368 /* test propget with lcid */
1369 dispparams
.cNamedArgs
= 0;
1370 dispparams
.cArgs
= 0;
1371 dispparams
.rgvarg
= NULL
;
1372 dispparams
.rgdispidNamedArgs
= NULL
;
1373 hr
= IDispatch_Invoke(pDispatch
, DISPID_TM_PROP_WITH_LCID
, &IID_NULL
, 0x40c, DISPATCH_PROPERTYGET
, &dispparams
, &varresult
, &excepinfo
, NULL
);
1376 ok_ole_success(hr
, ITypeInfo_Invoke
);
1377 ok(V_VT(&varresult
) == VT_I4
, "got %x\n", V_VT(&varresult
));
1378 ok(V_I4(&varresult
) == 0x409, "got %x\n", V_I4(&varresult
));
1380 VariantClear(&varresult
);
1382 IDispatch_Release(pDispatch
);
1383 IWidget_Release(pWidget
);
1385 trace("calling end_host_object\n");
1386 end_host_object(tid
, thread
);
1389 static void test_DispCallFunc(void)
1391 static const WCHAR szEmpty
[] = { 0 };
1392 VARTYPE rgvt
[] = { VT_R8
, VT_BSTR
, VT_BSTR
, VT_VARIANT
|VT_BYREF
};
1393 VARIANTARG vararg
[4];
1395 VARIANTARG
*rgpvarg
[4] = { &vararg
[0], &vararg
[1], &vararg
[2], &vararg
[3] };
1396 VARIANTARG varresult
;
1398 IWidget
*pWidget
= Widget_Create();
1399 V_VT(&vararg
[0]) = VT_R8
;
1400 V_R8(&vararg
[0]) = 3.141;
1401 V_VT(&vararg
[1]) = VT_BSTR
;
1402 V_BSTR(&vararg
[1]) = SysAllocString(szEmpty
);
1403 V_VT(&vararg
[2]) = VT_BSTR
;
1404 V_BSTR(&vararg
[2]) = SysAllocString(szEmpty
);
1405 V_VT(&vararg
[3]) = VT_VARIANT
|VT_BYREF
;
1406 V_VARIANTREF(&vararg
[3]) = &varref
;
1407 V_VT(&varref
) = VT_ERROR
;
1408 V_ERROR(&varref
) = DISP_E_PARAMNOTFOUND
;
1409 VariantInit(&varresult
);
1410 hr
= DispCallFunc(pWidget
, 9*sizeof(void*), CC_STDCALL
, VT_UI4
, 4, rgvt
, rgpvarg
, &varresult
);
1411 ok_ole_success(hr
, DispCallFunc
);
1412 VariantClear(&varresult
);
1413 VariantClear(&vararg
[1]);
1414 VariantClear(&vararg
[2]);
1415 IWidget_Release(pWidget
);
1418 static void test_StaticWidget(void)
1420 ITypeInfo
*type_info
;
1421 DISPPARAMS dispparams
;
1422 VARIANTARG vararg
[4];
1423 EXCEPINFO excepinfo
;
1427 type_info
= get_type_info(&IID_IStaticWidget
);
1430 dispparams
.cNamedArgs
= 0;
1431 dispparams
.cArgs
= 1;
1432 dispparams
.rgdispidNamedArgs
= NULL
;
1433 dispparams
.rgvarg
= vararg
;
1434 V_VT(vararg
) = VT_DISPATCH
;
1435 V_DISPATCH(vararg
) = (IDispatch
*)&TestDualDisp
;
1436 VariantInit(&varresult
);
1437 hr
= ITypeInfo_Invoke(type_info
, &StaticWidget
, DISPID_TM_TESTDUAL
, DISPATCH_METHOD
,
1438 &dispparams
, &varresult
, &excepinfo
, NULL
);
1439 ok_ole_success(hr
, IDispatch_Invoke
);
1440 ok(V_VT(&varresult
) == VT_EMPTY
, "vt %x\n", V_VT(&varresult
));
1441 VariantClear(&varresult
);
1443 ITypeInfo_Release(type_info
);
1446 START_TEST(tmarshal
)
1450 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
1452 hr
= register_current_module_typelib();
1453 ok_ole_success(hr
, register_current_module_typelib
);
1455 test_typelibmarshal();
1456 test_DispCallFunc();
1457 test_StaticWidget();
1459 hr
= UnRegisterTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
,
1460 sizeof(void*) == 8 ? SYS_WIN64
: SYS_WIN32
);
1461 ok_ole_success(hr
, UnRegisterTypeLib
);