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 IWidget IWidget_iface;
221 IUnknown *pDispatchUnknown;
224 static inline Widget *impl_from_IWidget(IWidget *iface)
226 return CONTAINING_RECORD(iface, Widget, IWidget_iface);
229 static HRESULT WINAPI Widget_QueryInterface(
231 /* [in] */ REFIID riid,
232 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
234 if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
236 IWidget_AddRef(iface);
243 return E_NOINTERFACE;
247 static ULONG WINAPI Widget_AddRef(
250 Widget *This = impl_from_IWidget(iface);
252 return InterlockedIncrement(&This->refs);
255 static ULONG WINAPI Widget_Release(
258 Widget *This = impl_from_IWidget(iface);
259 ULONG refs = InterlockedDecrement(&This->refs);
262 IUnknown_Release(This->pDispatchUnknown);
263 memset(This, 0xcc, sizeof(*This));
264 HeapFree(GetProcessHeap(), 0, This);
265 trace("Widget destroyed!\n");
271 static HRESULT WINAPI Widget_GetTypeInfoCount(
273 /* [out] */ UINT __RPC_FAR *pctinfo)
275 Widget *This = impl_from_IWidget(iface);
276 IDispatch *pDispatch;
277 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
280 hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
281 IDispatch_Release(pDispatch);
286 static HRESULT WINAPI Widget_GetTypeInfo(
287 IWidget __RPC_FAR * iface,
288 /* [in] */ UINT iTInfo,
289 /* [in] */ LCID lcid,
290 /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
292 Widget *This = impl_from_IWidget(iface);
293 IDispatch *pDispatch;
294 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
297 hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
298 IDispatch_Release(pDispatch);
303 static HRESULT WINAPI Widget_GetIDsOfNames(
304 IWidget __RPC_FAR * iface,
305 /* [in] */ REFIID riid,
306 /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
307 /* [in] */ UINT cNames,
308 /* [in] */ LCID lcid,
309 /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
311 Widget *This = impl_from_IWidget(iface);
312 IDispatch *pDispatch;
313 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
316 hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
317 IDispatch_Release(pDispatch);
322 static HRESULT WINAPI Widget_Invoke(
323 IWidget __RPC_FAR * iface,
324 /* [in] */ DISPID dispIdMember,
325 /* [in] */ REFIID riid,
326 /* [in] */ LCID lcid,
327 /* [in] */ WORD wFlags,
328 /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
329 /* [out] */ VARIANT __RPC_FAR *pVarResult,
330 /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
331 /* [out] */ UINT __RPC_FAR *puArgErr)
333 Widget *This = impl_from_IWidget(iface);
334 IDispatch *pDispatch;
335 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
338 hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
339 IDispatch_Release(pDispatch);
344 static HRESULT WINAPI Widget_put_Name(
345 IWidget __RPC_FAR * iface,
346 /* [in] */ BSTR name)
348 trace("put_Name(%s)\n", wine_dbgstr_w(name));
352 static HRESULT WINAPI Widget_get_Name(
353 IWidget __RPC_FAR * iface,
354 /* [out] */ BSTR __RPC_FAR *name)
356 static const WCHAR szCat[] = { 'C','a','t',0 };
357 trace("get_Name()\n");
358 *name = SysAllocString(szCat);
362 static HRESULT WINAPI Widget_DoSomething(
363 IWidget __RPC_FAR * iface,
364 /* [in] */ double number,
365 /* [out] */ BSTR *str1,
366 /* [defaultvalue][in] */ BSTR str2,
367 /* [optional][in] */ VARIANT __RPC_FAR *opt)
369 static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
370 trace("DoSomething()\n");
372 ok(number == 3.141, "number(%f) != 3.141\n", number);
373 ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
374 ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
375 ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
376 *str1 = SysAllocString(szString);
381 static HRESULT WINAPI Widget_get_State(
382 IWidget __RPC_FAR * iface,
383 /* [retval][out] */ STATE __RPC_FAR *state)
385 trace("get_State() = STATE_WIDGETIFIED\n");
386 *state = STATE_WIDGETIFIED;
390 static HRESULT WINAPI Widget_put_State(
391 IWidget __RPC_FAR * iface,
392 /* [in] */ STATE state)
394 trace("put_State(%d)\n", state);
398 static HRESULT WINAPI Widget_Map(
403 trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
404 *sValue = SysAllocString(bstrId);
408 static HRESULT WINAPI Widget_SetOleColor(
412 trace("SetOleColor(0x%x)\n", val);
416 static HRESULT WINAPI Widget_GetOleColor(
420 trace("GetOleColor() = 0x8000000f\n");
425 static HRESULT WINAPI Widget_Clone(
430 return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
433 static HRESULT WINAPI Widget_CloneDispatch(
437 trace("CloneDispatch()\n");
438 return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
441 static HRESULT WINAPI Widget_CloneCoclass(
443 ApplicationObject2 **ppVal)
445 trace("CloneCoclass()\n");
449 static HRESULT WINAPI Widget_Value(
450 IWidget __RPC_FAR * iface,
454 trace("Value(%p, %p)\n", value, retval);
455 ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
456 ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
457 V_VT(retval) = VT_I2;
462 static HRESULT WINAPI Widget_Array(
466 trace("Array(%p)\n", values);
470 static HRESULT WINAPI Widget_VariantArrayPtr(
474 trace("VariantArrayPtr(%p)\n", values);
478 static HRESULT WINAPI Widget_Variant(
479 IWidget __RPC_FAR * iface,
482 trace("Variant()\n");
483 ok(V_VT(&var) == VT_CY, "V_VT(&var) was %d\n", V_VT(&var));
484 ok(S(V_CY(&var)).Hi == 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var)).Hi);
485 ok(S(V_CY(&var)).Lo == 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var)).Lo);
489 static HRESULT WINAPI Widget_VarArg(
494 LONG lbound, ubound, i;
498 trace("VarArg(%p)\n", values);
500 hr = SafeArrayGetLBound(values, 1, &lbound);
501 ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
502 ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
504 hr = SafeArrayGetUBound(values, 1, &ubound);
505 ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
506 ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
508 hr = SafeArrayAccessData(values, (LPVOID)&data);
509 ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
511 for (i=0; i<=ubound-lbound; i++)
513 ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
514 ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
517 hr = SafeArrayUnaccessData(values);
518 ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
523 static HRESULT WINAPI Widget_StructArgs(
530 ok(byval.field1 == MYSTRUCT_BYVAL.field1 &&
531 byval.field2 == MYSTRUCT_BYVAL.field2,
532 "Struct parameter passed by value corrupted\n");
533 ok(byptr->field1 == MYSTRUCT_BYPTR.field1 &&
534 byptr->field2 == MYSTRUCT_BYPTR.field2,
535 "Struct parameter passed by pointer corrupted\n");
536 for (i = 0; i < 5; i++)
537 if (arr[i].field1 != MYSTRUCT_ARRAY[i].field1 ||
538 arr[i].field2 != MYSTRUCT_ARRAY[i].field2)
540 ok(diff == 0, "Array of structs corrupted\n");
545 static HRESULT WINAPI Widget_Error(
546 IWidget __RPC_FAR * iface)
552 static HRESULT WINAPI Widget_CloneInterface(
553 IWidget __RPC_FAR * iface,
554 ISomethingFromDispatch **ppVal)
556 trace("CloneInterface()\n");
561 static HRESULT WINAPI Widget_put_prop_with_lcid(
562 IWidget* iface, LONG lcid, INT i)
564 trace("put_prop_with_lcid(%08x, %x)\n", lcid, i);
565 ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
566 ok(i == 0xcafe, "got %08x\n", i);
570 static HRESULT WINAPI Widget_get_prop_with_lcid(
571 IWidget* iface, LONG lcid, INT *i)
573 trace("get_prop_with_lcid(%08x, %p)\n", lcid, i);
574 ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
579 static HRESULT WINAPI Widget_get_prop_int(
580 IWidget* iface, INT *i)
582 trace("get_prop_int(%p)\n", i);
587 static HRESULT WINAPI Widget_get_prop_uint(
588 IWidget* iface, UINT *i)
590 trace("get_prop_uint(%p)\n", i);
595 static HRESULT WINAPI Widget_ByRefUInt(
596 IWidget* iface, UINT *i)
602 static HRESULT WINAPI Widget_put_prop_opt_arg(
603 IWidget* iface, INT opt, INT i)
605 trace("put_prop_opt_arg(%08x, %08x)\n", opt, i);
606 todo_wine ok(opt == 0, "got opt=%08x\n", opt);
607 ok(i == 0xcafe, "got i=%08x\n", i);
611 static HRESULT WINAPI Widget_put_prop_req_arg(
612 IWidget* iface, INT req, INT i)
614 trace("put_prop_req_arg(%08x, %08x)\n", req, i);
615 ok(req == 0x5678, "got req=%08x\n", req);
616 ok(i == 0x1234, "got i=%08x\n", i);
620 static const struct IWidgetVtbl Widget_VTable =
622 Widget_QueryInterface,
625 Widget_GetTypeInfoCount,
627 Widget_GetIDsOfNames,
638 Widget_CloneDispatch,
642 Widget_VariantArrayPtr,
647 Widget_CloneInterface,
648 Widget_put_prop_with_lcid,
649 Widget_get_prop_with_lcid,
651 Widget_get_prop_uint,
653 Widget_put_prop_opt_arg,
654 Widget_put_prop_req_arg,
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 IKindaEnumWidget IKindaEnumWidget_iface;
735 static inline KindaEnum *impl_from_IKindaEnumWidget(IKindaEnumWidget *iface)
737 return CONTAINING_RECORD(iface, KindaEnum, IKindaEnumWidget_iface);
740 static HRESULT register_current_module_typelib(void)
742 WCHAR path[MAX_PATH];
743 CHAR pathA[MAX_PATH];
747 GetModuleFileNameA(NULL, pathA, MAX_PATH);
748 MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
750 hr = LoadTypeLib(path, &typelib);
753 hr = RegisterTypeLib(typelib, path, NULL);
754 ITypeLib_Release(typelib);
759 static ITypeInfo *get_type_info(REFIID riid)
761 ITypeInfo *pTypeInfo;
765 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
766 ok_ole_success(hr, LoadRegTypeLib);
770 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
771 ITypeLib_Release(pTypeLib);
772 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
779 static IWidget *Widget_Create(void)
782 ITypeInfo *pTypeInfo;
785 pTypeInfo = get_type_info(&IID_IWidget);
789 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
790 This->IWidget_iface.lpVtbl = &Widget_VTable;
792 This->pDispatchUnknown = NULL;
794 hr = CreateStdDispatch((IUnknown *)&This->IWidget_iface, This, pTypeInfo,
795 &This->pDispatchUnknown);
796 ok_ole_success(hr, CreateStdDispatch);
797 ITypeInfo_Release(pTypeInfo);
800 return &This->IWidget_iface;
803 HeapFree(GetProcessHeap(), 0, This);
808 static HRESULT WINAPI KindaEnum_QueryInterface(
809 IKindaEnumWidget *iface,
810 /* [in] */ REFIID riid,
811 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
813 if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
815 IKindaEnumWidget_AddRef(iface);
822 return E_NOINTERFACE;
826 static ULONG WINAPI KindaEnum_AddRef(
827 IKindaEnumWidget *iface)
829 KindaEnum *This = impl_from_IKindaEnumWidget(iface);
831 return InterlockedIncrement(&This->refs);
834 static ULONG WINAPI KindaEnum_Release(
835 IKindaEnumWidget *iface)
837 KindaEnum *This = impl_from_IKindaEnumWidget(iface);
838 ULONG refs = InterlockedDecrement(&This->refs);
841 memset(This, 0xcc, sizeof(*This));
842 HeapFree(GetProcessHeap(), 0, This);
843 trace("KindaEnumWidget destroyed!\n");
849 static HRESULT WINAPI KindaEnum_Next(
850 IKindaEnumWidget *iface,
851 /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
853 *widget = Widget_Create();
857 return E_OUTOFMEMORY;
860 static HRESULT WINAPI KindaEnum_Count(
861 IKindaEnumWidget *iface,
862 /* [out] */ ULONG __RPC_FAR *count)
867 static HRESULT WINAPI KindaEnum_Reset(
868 IKindaEnumWidget *iface)
873 static HRESULT WINAPI KindaEnum_Clone(
874 IKindaEnumWidget *iface,
875 /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
880 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
882 KindaEnum_QueryInterface,
891 static IKindaEnumWidget *KindaEnumWidget_Create(void)
895 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
896 if (!This) return NULL;
897 This->IKindaEnumWidget_iface.lpVtbl = &KindaEnumWidget_VTable;
899 return &This->IKindaEnumWidget_iface;
902 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
904 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
906 *(INonOleAutomation **)ppv = iface;
910 return E_NOINTERFACE;
913 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
918 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
923 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
925 static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
926 return SysAllocString(wszTestString);
929 static HRESULT WINAPI NonOleAutomation_Error(INonOleAutomation *iface)
934 static INonOleAutomationVtbl NonOleAutomation_VTable =
936 NonOleAutomation_QueryInterface,
937 NonOleAutomation_AddRef,
938 NonOleAutomation_Release,
939 NonOleAutomation_BstrRet,
940 NonOleAutomation_Error
943 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
945 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
948 HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
949 ok_ole_success(hr, LoadRegTypeLib);
952 ITypeInfo *pTypeInfo;
953 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
954 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
955 ITypeLib_Release(pTypeLib);
961 static void test_typelibmarshal(void)
963 static const WCHAR szCat[] = { 'C','a','t',0 };
964 static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
965 static WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
967 IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
970 IDispatch *pDispatch;
971 static const LARGE_INTEGER ullZero;
974 DISPID dispidNamed = DISPID_PROPERTYPUT;
975 DISPPARAMS dispparams;
976 VARIANTARG vararg[4];
981 ITypeInfo *pTypeInfo;
983 MYSTRUCT mystructArray[5];
986 ok(pKEW != NULL, "Widget creation failed\n");
988 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
989 ok_ole_success(hr, CreateStreamOnHGlobal);
990 tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
991 IKindaEnumWidget_Release(pKEW);
993 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
994 hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
995 ok_ole_success(hr, CoUnmarshalInterface);
996 IStream_Release(pStream);
998 hr = IKindaEnumWidget_Next(pKEW, &pWidget);
999 ok_ole_success(hr, IKindaEnumWidget_Next);
1001 IKindaEnumWidget_Release(pKEW);
1003 hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
1004 ok_ole_success(hr, IWidget_QueryInterface);
1007 VariantInit(&vararg[0]);
1008 dispparams.cNamedArgs = 1;
1009 dispparams.rgdispidNamedArgs = &dispidNamed;
1010 dispparams.cArgs = 1;
1011 dispparams.rgvarg = vararg;
1012 VariantInit(&varresult);
1013 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1014 ok_ole_success(hr, IDispatch_Invoke);
1015 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1016 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1017 excepinfo.wCode, excepinfo.scode);
1018 VariantClear(&varresult);
1020 /* call put_Name (direct) */
1021 bstr = SysAllocString(szSuperman);
1022 hr = IWidget_put_Name(pWidget, bstr);
1023 ok_ole_success(hr, IWidget_put_Name);
1024 SysFreeString(bstr);
1027 dispparams.cNamedArgs = 0;
1028 dispparams.rgdispidNamedArgs = NULL;
1029 dispparams.cArgs = 0;
1030 dispparams.rgvarg = NULL;
1031 VariantInit(&varresult);
1032 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1033 ok_ole_success(hr, IDispatch_Invoke);
1034 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1035 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1036 excepinfo.wCode, excepinfo.scode);
1037 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1038 VariantClear(&varresult);
1040 /* call get_Name (direct) */
1042 hr = IWidget_get_Name(pWidget, &bstr);
1043 ok_ole_success(hr, IWidget_get_Name);
1044 ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
1045 SysFreeString(bstr);
1047 /* call DoSomething */
1048 VariantInit(&vararg[0]);
1049 VariantInit(&vararg[1]);
1050 V_VT(&vararg[1]) = VT_R8;
1051 V_R8(&vararg[1]) = 3.141;
1052 dispparams.cNamedArgs = 0;
1053 dispparams.cArgs = 2;
1054 dispparams.rgdispidNamedArgs = NULL;
1055 dispparams.rgvarg = vararg;
1056 VariantInit(&varresult);
1057 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1058 ok_ole_success(hr, IDispatch_Invoke);
1059 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1060 VariantClear(&varresult);
1062 /* call get_State */
1063 dispparams.cNamedArgs = 0;
1064 dispparams.cArgs = 0;
1065 dispparams.rgdispidNamedArgs = NULL;
1066 dispparams.rgvarg = NULL;
1067 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1068 ok_ole_success(hr, IDispatch_Invoke);
1069 ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
1071 /* call get_State (direct) */
1072 hr = IWidget_get_State(pWidget, &the_state);
1073 ok_ole_success(hr, IWidget_get_state);
1074 ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
1076 /* call put_State */
1077 the_state = STATE_WIDGETIFIED;
1078 VariantInit(&vararg[0]);
1079 V_VT(&vararg[0]) = VT_BYREF|VT_I4;
1080 V_I4REF(&vararg[0]) = (int *)&the_state;
1081 dispparams.cNamedArgs = 1;
1082 dispparams.cArgs = 1;
1083 dispparams.rgdispidNamedArgs = &dispidNamed;
1084 dispparams.rgvarg = vararg;
1085 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1086 ok_ole_success(hr, IDispatch_Invoke);
1089 bstr = SysAllocString(szTestTest);
1090 VariantInit(&vararg[0]);
1091 V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
1092 V_BSTRREF(&vararg[0]) = &bstr;
1093 dispparams.cNamedArgs = 0;
1094 dispparams.cArgs = 1;
1095 dispparams.rgdispidNamedArgs = NULL;
1096 dispparams.rgvarg = vararg;
1097 VariantInit(&varresult);
1098 hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1099 ok_ole_success(hr, IDispatch_Invoke);
1100 ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
1101 ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1102 VariantClear(&varresult);
1103 SysFreeString(bstr);
1105 /* call SetOleColor with large negative VT_I4 param */
1106 VariantInit(&vararg[0]);
1107 V_VT(&vararg[0]) = VT_I4;
1108 V_I4(&vararg[0]) = 0x80000005;
1109 dispparams.cNamedArgs = 0;
1110 dispparams.cArgs = 1;
1111 dispparams.rgdispidNamedArgs = NULL;
1112 dispparams.rgvarg = vararg;
1113 hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1114 ok_ole_success(hr, IDispatch_Invoke);
1116 /* call GetOleColor */
1117 dispparams.cNamedArgs = 0;
1118 dispparams.cArgs = 0;
1119 dispparams.rgdispidNamedArgs = NULL;
1120 dispparams.rgvarg = NULL;
1121 VariantInit(&varresult);
1122 hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1123 ok_ole_success(hr, IDispatch_Invoke);
1124 VariantClear(&varresult);
1126 /* call StructArgs (direct) */
1127 mystruct = MYSTRUCT_BYPTR;
1128 memcpy(mystructArray, MYSTRUCT_ARRAY, sizeof(mystructArray));
1129 hr = IWidget_StructArgs(pWidget, MYSTRUCT_BYVAL, &mystruct, mystructArray);
1130 ok_ole_success(hr, IWidget_StructArgs);
1133 dispparams.cNamedArgs = 0;
1134 dispparams.cArgs = 0;
1135 dispparams.rgdispidNamedArgs = NULL;
1136 dispparams.rgvarg = NULL;
1137 VariantInit(&varresult);
1138 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1139 ok_ole_success(hr, IDispatch_Invoke);
1140 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1141 VariantClear(&varresult);
1143 /* call CloneInterface */
1144 dispparams.cNamedArgs = 0;
1145 dispparams.cArgs = 0;
1146 dispparams.rgdispidNamedArgs = NULL;
1147 dispparams.rgvarg = NULL;
1148 VariantInit(&varresult);
1149 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1150 ok_ole_success(hr, IDispatch_Invoke);
1151 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1152 VariantClear(&varresult);
1154 /* call CloneDispatch with automatic value getting */
1155 V_VT(&vararg[0]) = VT_I2;
1156 V_I2(&vararg[0]) = 1;
1157 dispparams.cNamedArgs = 0;
1158 dispparams.rgdispidNamedArgs = NULL;
1159 dispparams.cArgs = 1;
1160 dispparams.rgvarg = vararg;
1161 VariantInit(&varresult);
1162 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1163 ok_ole_success(hr, IDispatch_Invoke);
1165 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1166 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1167 excepinfo.wCode, excepinfo.scode);
1169 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1170 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1171 VariantClear(&varresult);
1173 /* call CloneCoclass */
1174 dispparams.cNamedArgs = 0;
1175 dispparams.cArgs = 0;
1176 dispparams.rgdispidNamedArgs = NULL;
1177 dispparams.rgvarg = NULL;
1178 VariantInit(&varresult);
1179 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1180 ok_ole_success(hr, IDispatch_Invoke);
1182 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1183 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1184 excepinfo.wCode, excepinfo.scode);
1186 ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
1187 ok(!V_DISPATCH(&varresult), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult));
1188 VariantClear(&varresult);
1190 /* call Value with a VT_VARIANT|VT_BYREF type */
1191 V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
1192 V_VARIANTREF(&vararg[0]) = &vararg[1];
1193 V_VT(&vararg[1]) = VT_I2;
1194 V_I2(&vararg[1]) = 1;
1195 dispparams.cNamedArgs = 0;
1196 dispparams.rgdispidNamedArgs = NULL;
1197 dispparams.cArgs = 1;
1198 dispparams.rgvarg = vararg;
1199 VariantInit(&varresult);
1200 hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1201 ok_ole_success(hr, IDispatch_Invoke);
1203 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1204 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1205 excepinfo.wCode, excepinfo.scode);
1207 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1208 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1209 VariantClear(&varresult);
1211 /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1212 * handling of void return types */
1213 /* use a big type to ensure that the variant was properly copied into the
1214 * destination function's args */
1215 V_VT(&vararg[0]) = VT_CY;
1216 S(V_CY(&vararg[0])).Hi = 0xdababe;
1217 S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
1218 dispparams.cNamedArgs = 0;
1219 dispparams.cArgs = 1;
1220 dispparams.rgdispidNamedArgs = NULL;
1221 dispparams.rgvarg = vararg;
1222 VariantInit(&varresult);
1223 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1224 ok_ole_success(hr, IDispatch_Invoke);
1225 VariantClear(&varresult);
1228 VariantInit(&vararg[3]);
1229 V_VT(&vararg[3]) = VT_I4;
1230 V_I4(&vararg[3]) = 3;
1231 VariantInit(&vararg[2]);
1232 V_VT(&vararg[2]) = VT_I4;
1233 V_I4(&vararg[2]) = 0;
1234 VariantInit(&vararg[1]);
1235 V_VT(&vararg[1]) = VT_I4;
1236 V_I4(&vararg[1]) = 1;
1237 VariantInit(&vararg[0]);
1238 V_VT(&vararg[0]) = VT_I4;
1239 V_I4(&vararg[0]) = 2;
1240 dispparams.cNamedArgs = 0;
1241 dispparams.cArgs = 4;
1242 dispparams.rgdispidNamedArgs = NULL;
1243 dispparams.rgvarg = vararg;
1244 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1245 ok_ole_success(hr, ITypeInfo_Invoke);
1247 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1249 dispparams.cNamedArgs = 1;
1250 dispparams.rgdispidNamedArgs = &dispidNamed;
1251 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1252 ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
1253 dispidNamed = DISPID_PROPERTYPUT;
1256 dispparams.cNamedArgs = 0;
1257 dispparams.cArgs = 0;
1258 dispparams.rgdispidNamedArgs = NULL;
1259 dispparams.rgvarg = NULL;
1260 VariantInit(&varresult);
1261 hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1262 ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1263 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1264 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1265 excepinfo.wCode, excepinfo.scode);
1266 VariantClear(&varresult);
1269 pTypeInfo = NonOleAutomation_GetTypeInfo();
1270 dispparams.cNamedArgs = 0;
1271 dispparams.cArgs = 0;
1272 dispparams.rgdispidNamedArgs = NULL;
1273 dispparams.rgvarg = NULL;
1274 VariantInit(&varresult);
1275 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1276 ok_ole_success(hr, ITypeInfo_Invoke);
1277 ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
1278 ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
1280 VariantClear(&varresult);
1282 dispparams.cNamedArgs = 0;
1283 dispparams.cArgs = 0;
1284 dispparams.rgdispidNamedArgs = NULL;
1285 dispparams.rgvarg = NULL;
1286 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_ERROR, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1287 ok(hr == DISP_E_EXCEPTION, "ITypeInfo_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1288 ok(V_VT(&varresult) == VT_EMPTY, "V_VT(&varresult) should be VT_EMPTY instead of %d\n", V_VT(&varresult));
1289 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1290 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1291 excepinfo.wCode, excepinfo.scode);
1292 VariantClear(&varresult);
1294 ITypeInfo_Release(pTypeInfo);
1296 /* tests call put_Name without named arg */
1297 VariantInit(&vararg[0]);
1298 dispparams.cNamedArgs = 0;
1299 dispparams.rgdispidNamedArgs = NULL;
1300 dispparams.cArgs = 1;
1301 dispparams.rgvarg = vararg;
1302 VariantInit(&varresult);
1303 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1304 ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
1305 VariantClear(&varresult);
1307 /* tests param type that cannot be coerced */
1308 VariantInit(&vararg[0]);
1309 V_VT(&vararg[0]) = VT_UNKNOWN;
1310 V_UNKNOWN(&vararg[0]) = NULL;
1311 dispparams.cNamedArgs = 1;
1312 dispparams.rgdispidNamedArgs = &dispidNamed;
1313 dispparams.cArgs = 1;
1314 dispparams.rgvarg = vararg;
1315 VariantInit(&varresult);
1316 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1317 ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1318 VariantClear(&varresult);
1320 /* tests bad param type */
1321 VariantInit(&vararg[0]);
1322 V_VT(&vararg[0]) = VT_CLSID;
1323 V_BYREF(&vararg[0]) = NULL;
1324 dispparams.cNamedArgs = 1;
1325 dispparams.rgdispidNamedArgs = &dispidNamed;
1326 dispparams.cArgs = 1;
1327 dispparams.rgvarg = vararg;
1328 VariantInit(&varresult);
1329 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1330 ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1331 VariantClear(&varresult);
1333 /* tests too small param count */
1334 dispparams.cNamedArgs = 0;
1335 dispparams.rgdispidNamedArgs = NULL;
1336 dispparams.cArgs = 0;
1337 dispparams.rgvarg = NULL;
1338 VariantInit(&varresult);
1339 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1340 ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1341 VariantClear(&varresult);
1343 /* tests propget function with large param count */
1344 VariantInit(&vararg[0]);
1345 V_VT(&vararg[0]) = VT_BSTR;
1346 V_BSTR(&vararg[0]) = NULL;
1347 V_VT(&vararg[1]) = VT_I4;
1348 V_I4(&vararg[1]) = 1;
1349 dispparams.cNamedArgs = 0;
1350 dispparams.cArgs = 2;
1351 dispparams.rgdispidNamedArgs = NULL;
1352 dispparams.rgvarg = vararg;
1353 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1354 ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1356 /* test propput with lcid */
1358 /* the lcid passed to the function is the first lcid in the typelib header.
1359 Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1360 VariantInit(&vararg[0]);
1361 V_VT(&vararg[0]) = VT_I4;
1362 V_I4(&vararg[0]) = 0xcafe;
1363 dispparams.cNamedArgs = 1;
1364 dispparams.rgdispidNamedArgs = &dispidNamed;
1365 dispparams.cArgs = 1;
1366 dispparams.rgvarg = vararg;
1367 VariantInit(&varresult);
1368 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1369 ok_ole_success(hr, ITypeInfo_Invoke);
1370 VariantClear(&varresult);
1372 /* test propget with lcid */
1373 dispparams.cNamedArgs = 0;
1374 dispparams.cArgs = 0;
1375 dispparams.rgvarg = NULL;
1376 dispparams.rgdispidNamedArgs = NULL;
1377 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1378 ok_ole_success(hr, ITypeInfo_Invoke);
1379 ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1380 ok(V_I4(&varresult) == 0x409, "got %x\n", V_I4(&varresult));
1381 VariantClear(&varresult);
1383 /* test propget of INT value */
1384 dispparams.cNamedArgs = 0;
1385 dispparams.cArgs = 0;
1386 dispparams.rgvarg = NULL;
1387 dispparams.rgdispidNamedArgs = NULL;
1388 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_INT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1389 ok_ole_success(hr, ITypeInfo_Invoke);
1390 ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1391 ok(V_I4(&varresult) == -13, "got %x\n", V_I4(&varresult));
1392 VariantClear(&varresult);
1394 /* test propget of INT value */
1395 dispparams.cNamedArgs = 0;
1396 dispparams.cArgs = 0;
1397 dispparams.rgvarg = NULL;
1398 dispparams.rgdispidNamedArgs = NULL;
1399 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_UINT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1400 ok_ole_success(hr, ITypeInfo_Invoke);
1401 ok(V_VT(&varresult) == VT_UI4, "got %x\n", V_VT(&varresult));
1402 ok(V_UI4(&varresult) == 42, "got %x\n", V_UI4(&varresult));
1403 VariantClear(&varresult);
1405 /* test byref marshalling */
1407 VariantInit(&vararg[0]);
1408 V_VT(&vararg[0]) = VT_UI4|VT_BYREF;
1409 V_UI4REF(&vararg[0]) = &uval;
1410 dispparams.cNamedArgs = 0;
1411 dispparams.cArgs = 1;
1412 dispparams.rgvarg = vararg;
1413 dispparams.rgdispidNamedArgs = NULL;
1414 hr = IDispatch_Invoke(pDispatch, DISPID_TM_BYREF_UINT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1415 ok_ole_success(hr, ITypeInfo_Invoke);
1416 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1417 ok(V_VT(&vararg[0]) == (VT_UI4|VT_BYREF), "arg VT not unmarshalled correctly: %x\n", V_VT(&vararg[0]));
1418 ok(V_UI4REF(&vararg[0]) == &uval, "Byref pointer not preserved: %p/%p\n", &uval, V_UI4REF(&vararg[0]));
1419 ok(*V_UI4REF(&vararg[0]) == 42, "Expected 42 to be returned instead of %u\n", *V_UI4REF(&vararg[0]));
1420 VariantClear(&varresult);
1421 VariantClear(&vararg[0]);
1423 /* test propput with optional argument. */
1424 VariantInit(&vararg[0]);
1425 V_VT(&vararg[0]) = VT_I4;
1426 V_I4(&vararg[0]) = 0xcafe;
1427 dispparams.cNamedArgs = 1;
1428 dispparams.rgdispidNamedArgs = &dispidNamed;
1429 dispparams.cArgs = 1;
1430 dispparams.rgvarg = vararg;
1431 VariantInit(&varresult);
1432 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_OPT_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1433 ok_ole_success(hr, ITypeInfo_Invoke);
1434 VariantClear(&varresult);
1436 /* test propput with required argument. */
1437 VariantInit(&vararg[0]);
1438 VariantInit(&vararg[1]);
1439 V_VT(&vararg[0]) = VT_I4;
1440 V_I4(&vararg[0]) = 0x1234;
1441 V_VT(&vararg[1]) = VT_I4;
1442 V_I4(&vararg[1]) = 0x5678;
1443 dispparams.cNamedArgs = 1;
1444 dispparams.rgdispidNamedArgs = &dispidNamed;
1445 dispparams.cArgs = 2;
1446 dispparams.rgvarg = vararg;
1447 VariantInit(&varresult);
1448 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_REQ_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1449 ok_ole_success(hr, ITypeInfo_Invoke);
1450 VariantClear(&varresult);
1452 IDispatch_Release(pDispatch);
1453 IWidget_Release(pWidget);
1455 trace("calling end_host_object\n");
1456 end_host_object(tid, thread);
1459 static void test_DispCallFunc(void)
1461 static const WCHAR szEmpty[] = { 0 };
1462 VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1463 VARIANTARG vararg[4];
1465 VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1466 VARIANTARG varresult;
1468 IWidget *pWidget = Widget_Create();
1469 V_VT(&vararg[0]) = VT_R8;
1470 V_R8(&vararg[0]) = 3.141;
1471 V_VT(&vararg[1]) = VT_BSTR;
1472 V_BSTRREF(&vararg[1]) = CoTaskMemAlloc(sizeof(BSTR));
1473 V_VT(&vararg[2]) = VT_BSTR;
1474 V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1475 V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1476 V_VARIANTREF(&vararg[3]) = &varref;
1477 V_VT(&varref) = VT_ERROR;
1478 V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1479 VariantInit(&varresult);
1480 hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1481 ok_ole_success(hr, DispCallFunc);
1482 VariantClear(&varresult);
1483 SysFreeString(*V_BSTRREF(&vararg[1]));
1484 CoTaskMemFree(V_BSTRREF(&vararg[1]));
1485 VariantClear(&vararg[2]);
1486 IWidget_Release(pWidget);
1489 static void test_StaticWidget(void)
1491 ITypeInfo *type_info;
1492 DISPPARAMS dispparams;
1493 VARIANTARG vararg[4];
1494 EXCEPINFO excepinfo;
1498 type_info = get_type_info(&IID_IStaticWidget);
1501 dispparams.cNamedArgs = 0;
1502 dispparams.cArgs = 1;
1503 dispparams.rgdispidNamedArgs = NULL;
1504 dispparams.rgvarg = vararg;
1505 V_VT(vararg) = VT_DISPATCH;
1506 V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1507 VariantInit(&varresult);
1508 hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
1509 &dispparams, &varresult, &excepinfo, NULL);
1510 ok_ole_success(hr, IDispatch_Invoke);
1511 ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1512 VariantClear(&varresult);
1514 ITypeInfo_Release(type_info);
1517 static void test_libattr(void)
1523 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
1524 ok_ole_success(hr, LoadRegTypeLib);
1528 hr = ITypeLib_GetLibAttr(pTypeLib, &pattr);
1529 ok_ole_success(hr, GetLibAttr);
1532 ok(pattr->lcid == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), "lcid %x\n", pattr->lcid);
1534 ITypeLib_ReleaseTLibAttr(pTypeLib, pattr);
1537 ITypeLib_Release(pTypeLib);
1540 START_TEST(tmarshal)
1544 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1546 hr = register_current_module_typelib();
1547 ok_ole_success(hr, register_current_module_typelib);
1549 test_typelibmarshal();
1550 test_DispCallFunc();
1551 test_StaticWidget();
1554 hr = UnRegisterTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL,
1555 sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
1556 ok_ole_success(hr, UnRegisterTypeLib);