2 * Copyright (C) 2005-2006 Robert Shearman for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wine/test.h"
30 #include "tmarshal_dispids.h"
32 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", (unsigned long int)hr)
34 /* ULL suffix is not portable */
35 #define ULL_CONST(dw1, dw2) ((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)
37 const MYSTRUCT MYSTRUCT_BYVAL = {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432)};
38 const MYSTRUCT MYSTRUCT_BYPTR = {0x91827364, ULL_CONST(0x88776655, 0x44332211)};
39 const MYSTRUCT MYSTRUCT_ARRAY[5] = {
40 {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415)},
41 {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425)},
42 {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435)},
43 {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445)},
44 {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455)},
48 #define RELEASEMARSHALDATA WM_USER
50 struct host_object_data
55 MSHLFLAGS marshal_flags;
57 IMessageFilter *filter;
60 static DWORD CALLBACK host_object_proc(LPVOID p)
62 struct host_object_data *data = p;
66 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
70 IMessageFilter * prev_filter = NULL;
71 hr = CoRegisterMessageFilter(data->filter, &prev_filter);
72 if (prev_filter) IMessageFilter_Release(prev_filter);
73 ok_ole_success(hr, CoRegisterMessageFilter);
76 hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
77 ok_ole_success(hr, CoMarshalInterface);
79 /* force the message queue to be created before signaling parent thread */
80 PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
82 SetEvent(data->marshal_event);
84 while (GetMessage(&msg, NULL, 0, 0))
86 if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
88 trace("releasing marshal data\n");
89 CoReleaseMarshalData(data->stream);
90 SetEvent((HANDLE)msg.lParam);
93 DispatchMessage(&msg);
96 HeapFree(GetProcessHeap(), 0, data);
103 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
106 HANDLE marshal_event = CreateEvent(NULL, FALSE, FALSE, NULL);
107 struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
109 data->stream = stream;
111 data->object = object;
112 data->marshal_flags = marshal_flags;
113 data->marshal_event = marshal_event;
114 data->filter = filter;
116 *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
118 /* wait for marshaling to complete before returning */
119 WaitForSingleObject(marshal_event, INFINITE);
120 CloseHandle(marshal_event);
125 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
127 return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
131 /* asks thread to release the marshal data because it has to be done by the
132 * same thread that marshaled the interface in the first place. */
133 static void release_host_object(DWORD tid)
135 HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
136 PostThreadMessage(tid, RELEASEMARSHALDATA, 0, (LPARAM)event);
137 WaitForSingleObject(event, INFINITE);
142 static void end_host_object(DWORD tid, HANDLE thread)
144 BOOL ret = PostThreadMessage(tid, WM_QUIT, 0, 0);
145 ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
146 /* be careful of races - don't return until hosting thread has terminated */
147 WaitForSingleObject(thread, INFINITE);
151 static ItestDual TestDual, TestDualDisp;
153 static HRESULT WINAPI TestDual_QueryInterface(ItestDual *iface, REFIID riid, void **ppvObject)
155 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch)) {
156 *ppvObject = &TestDualDisp;
158 }else if(IsEqualGUID(riid, &IID_ItestDual)) {
159 *ppvObject = &TestDual;
164 return E_NOINTERFACE;
167 static ULONG WINAPI TestDual_AddRef(ItestDual *iface)
172 static ULONG WINAPI TestDual_Release(ItestDual *iface)
177 static HRESULT WINAPI TestDual_GetTypeInfoCount(ItestDual *iface, UINT *pctinfo)
179 ok(0, "unexpected call\n");
183 static HRESULT WINAPI TestDual_GetTypeInfo(ItestDual *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
185 ok(0, "unexpected call\n");
189 static HRESULT WINAPI TestDual_GetIDsOfNames(ItestDual *iface, REFIID riid, LPOLESTR *rgszNames,
190 UINT cNames, LCID lcid, DISPID *rgDispId)
192 ok(0, "unexpected call\n");
196 static HRESULT WINAPI TestDual_Invoke(ItestDual *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
197 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
200 ok(0, "unexpected call\n");
204 static ItestDualVtbl TestDualVtbl = {
205 TestDual_QueryInterface,
208 TestDual_GetTypeInfoCount,
209 TestDual_GetTypeInfo,
210 TestDual_GetIDsOfNames,
214 static ItestDual TestDual = { &TestDualVtbl };
215 static ItestDual TestDualDisp = { &TestDualVtbl };
217 typedef struct Widget
219 const IWidgetVtbl *lpVtbl;
221 IUnknown *pDispatchUnknown;
224 static HRESULT WINAPI Widget_QueryInterface(
226 /* [in] */ REFIID riid,
227 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
229 if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
231 IWidget_AddRef(iface);
238 return E_NOINTERFACE;
242 static ULONG WINAPI Widget_AddRef(
245 Widget *This = (Widget *)iface;
247 return InterlockedIncrement(&This->refs);
250 static ULONG WINAPI Widget_Release(
253 Widget *This = (Widget *)iface;
254 ULONG refs = InterlockedDecrement(&This->refs);
257 IUnknown_Release(This->pDispatchUnknown);
258 memset(This, 0xcc, sizeof(*This));
259 HeapFree(GetProcessHeap(), 0, This);
260 trace("Widget destroyed!\n");
266 static HRESULT WINAPI Widget_GetTypeInfoCount(
268 /* [out] */ UINT __RPC_FAR *pctinfo)
270 Widget *This = (Widget *)iface;
271 IDispatch *pDispatch;
272 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
275 hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
276 IDispatch_Release(pDispatch);
281 static HRESULT WINAPI Widget_GetTypeInfo(
282 IWidget __RPC_FAR * iface,
283 /* [in] */ UINT iTInfo,
284 /* [in] */ LCID lcid,
285 /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
287 Widget *This = (Widget *)iface;
288 IDispatch *pDispatch;
289 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
292 hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
293 IDispatch_Release(pDispatch);
298 static HRESULT WINAPI Widget_GetIDsOfNames(
299 IWidget __RPC_FAR * iface,
300 /* [in] */ REFIID riid,
301 /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
302 /* [in] */ UINT cNames,
303 /* [in] */ LCID lcid,
304 /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
306 Widget *This = (Widget *)iface;
307 IDispatch *pDispatch;
308 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
311 hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
312 IDispatch_Release(pDispatch);
317 static HRESULT WINAPI Widget_Invoke(
318 IWidget __RPC_FAR * iface,
319 /* [in] */ DISPID dispIdMember,
320 /* [in] */ REFIID riid,
321 /* [in] */ LCID lcid,
322 /* [in] */ WORD wFlags,
323 /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
324 /* [out] */ VARIANT __RPC_FAR *pVarResult,
325 /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
326 /* [out] */ UINT __RPC_FAR *puArgErr)
328 Widget *This = (Widget *)iface;
329 IDispatch *pDispatch;
330 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
333 hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
334 IDispatch_Release(pDispatch);
339 static HRESULT WINAPI Widget_put_Name(
340 IWidget __RPC_FAR * iface,
341 /* [in] */ BSTR name)
343 trace("put_Name(%s)\n", wine_dbgstr_w(name));
347 static HRESULT WINAPI Widget_get_Name(
348 IWidget __RPC_FAR * iface,
349 /* [out] */ BSTR __RPC_FAR *name)
351 static const WCHAR szCat[] = { 'C','a','t',0 };
352 trace("get_Name()\n");
353 *name = SysAllocString(szCat);
357 static HRESULT WINAPI Widget_DoSomething(
358 IWidget __RPC_FAR * iface,
359 /* [in] */ double number,
360 /* [out] */ BSTR *str1,
361 /* [defaultvalue][in] */ BSTR str2,
362 /* [optional][in] */ VARIANT __RPC_FAR *opt)
364 static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
365 trace("DoSomething()\n");
367 ok(number == 3.141, "number(%f) != 3.141\n", number);
368 ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
369 ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
370 ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
371 *str1 = SysAllocString(szString);
376 static HRESULT WINAPI Widget_get_State(
377 IWidget __RPC_FAR * iface,
378 /* [retval][out] */ STATE __RPC_FAR *state)
380 trace("get_State() = STATE_WIDGETIFIED\n");
381 *state = STATE_WIDGETIFIED;
385 static HRESULT WINAPI Widget_put_State(
386 IWidget __RPC_FAR * iface,
387 /* [in] */ STATE state)
389 trace("put_State(%d)\n", state);
393 static HRESULT WINAPI Widget_Map(
398 trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
399 *sValue = SysAllocString(bstrId);
403 static HRESULT WINAPI Widget_SetOleColor(
407 trace("SetOleColor(0x%x)\n", val);
411 static HRESULT WINAPI Widget_GetOleColor(
415 trace("GetOleColor() = 0x8000000f\n");
420 static HRESULT WINAPI Widget_Clone(
425 return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
428 static HRESULT WINAPI Widget_CloneDispatch(
432 trace("CloneDispatch()\n");
433 return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
436 static HRESULT WINAPI Widget_CloneCoclass(
438 ApplicationObject2 **ppVal)
440 trace("CloneCoclass()\n");
444 static HRESULT WINAPI Widget_Value(
445 IWidget __RPC_FAR * iface,
449 trace("Value(%p, %p)\n", value, retval);
450 ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
451 ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
452 V_VT(retval) = VT_I2;
457 static HRESULT WINAPI Widget_Array(
461 trace("Array(%p)\n", values);
465 static HRESULT WINAPI Widget_VariantArrayPtr(
469 trace("VariantArrayPtr(%p)\n", values);
473 static HRESULT WINAPI Widget_Variant(
474 IWidget __RPC_FAR * iface,
477 trace("Variant()\n");
478 ok(V_VT(&var) == VT_CY, "V_VT(&var) was %d\n", V_VT(&var));
479 ok(S(V_CY(&var)).Hi == 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var)).Hi);
480 ok(S(V_CY(&var)).Lo == 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var)).Lo);
484 static HRESULT WINAPI Widget_VarArg(
489 LONG lbound, ubound, i;
493 trace("VarArg(%p)\n", values);
495 hr = SafeArrayGetLBound(values, 1, &lbound);
496 ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
497 ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
499 hr = SafeArrayGetUBound(values, 1, &ubound);
500 ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
501 ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
503 hr = SafeArrayAccessData(values, (LPVOID)&data);
504 ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
506 for (i=0; i<=ubound-lbound; i++)
508 ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
509 ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
512 hr = SafeArrayUnaccessData(values);
513 ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
518 static HRESULT WINAPI Widget_StructArgs(
524 ok(memcmp(&byval, &MYSTRUCT_BYVAL, sizeof(MYSTRUCT))==0, "Struct parameter passed by value corrupted\n");
525 ok(memcmp(byptr, &MYSTRUCT_BYPTR, sizeof(MYSTRUCT))==0, "Struct parameter passed by pointer corrupted\n");
526 ok(memcmp(arr, MYSTRUCT_ARRAY, sizeof(MYSTRUCT_ARRAY))==0, "Array of structs corrupted\n");
531 static HRESULT WINAPI Widget_Error(
532 IWidget __RPC_FAR * iface)
538 static HRESULT WINAPI Widget_CloneInterface(
539 IWidget __RPC_FAR * iface,
540 ISomethingFromDispatch **ppVal)
542 trace("CloneInterface()\n");
547 static HRESULT WINAPI Widget_put_prop_with_lcid(
548 IWidget* iface, LONG lcid, INT i)
550 trace("put_prop_with_lcid(%08x, %x)\n", lcid, i);
551 ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
552 ok(i == 0xcafe, "got %08x\n", i);
556 static HRESULT WINAPI Widget_get_prop_with_lcid(
557 IWidget* iface, LONG lcid, INT *i)
559 trace("get_prop_with_lcid(%08x, %p)\n", lcid, i);
560 ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
565 static const struct IWidgetVtbl Widget_VTable =
567 Widget_QueryInterface,
570 Widget_GetTypeInfoCount,
572 Widget_GetIDsOfNames,
583 Widget_CloneDispatch,
587 Widget_VariantArrayPtr,
592 Widget_CloneInterface,
593 Widget_put_prop_with_lcid,
594 Widget_get_prop_with_lcid
597 static HRESULT WINAPI StaticWidget_QueryInterface(IStaticWidget *iface, REFIID riid, void **ppvObject)
599 if (IsEqualIID(riid, &IID_IStaticWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
601 IStaticWidget_AddRef(iface);
607 return E_NOINTERFACE;
610 static ULONG WINAPI StaticWidget_AddRef(IStaticWidget *iface)
615 static ULONG WINAPI StaticWidget_Release(IStaticWidget *iface)
620 static HRESULT WINAPI StaticWidget_GetTypeInfoCount(IStaticWidget *iface, UINT *pctinfo)
622 ok(0, "unexpected call\n");
626 static HRESULT WINAPI StaticWidget_GetTypeInfo(IStaticWidget *iface, UINT iTInfo, LCID lcid,
629 ok(0, "unexpected call\n");
633 static HRESULT WINAPI StaticWidget_GetIDsOfNames(IStaticWidget *iface, REFIID riid, LPOLESTR *rgszNames,
634 UINT cNames, LCID lcid, DISPID *rgDispId)
636 ok(0, "unexpected call\n");
640 static HRESULT WINAPI StaticWidget_Invoke(IStaticWidget *iface, DISPID dispIdMember, REFIID riid,
641 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
644 ok(0, "unexpected call\n");
648 static HRESULT WINAPI StaticWidget_TestDual(IStaticWidget *iface, ItestDual *p)
650 trace("TestDual()\n");
652 ok(p == &TestDual, "wrong ItestDual\n");
656 static const IStaticWidgetVtbl StaticWidgetVtbl = {
657 StaticWidget_QueryInterface,
659 StaticWidget_Release,
660 StaticWidget_GetTypeInfoCount,
661 StaticWidget_GetTypeInfo,
662 StaticWidget_GetIDsOfNames,
664 StaticWidget_TestDual
667 static IStaticWidget StaticWidget = { &StaticWidgetVtbl };
669 typedef struct KindaEnum
671 const IKindaEnumWidgetVtbl *lpVtbl;
675 static HRESULT register_current_module_typelib(void)
677 WCHAR path[MAX_PATH];
678 CHAR pathA[MAX_PATH];
682 GetModuleFileNameA(NULL, pathA, MAX_PATH);
683 MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
685 hr = LoadTypeLib(path, &typelib);
688 hr = RegisterTypeLib(typelib, path, NULL);
689 ITypeLib_Release(typelib);
694 static ITypeInfo *get_type_info(REFIID riid)
696 ITypeInfo *pTypeInfo;
700 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
701 ok_ole_success(hr, LoadRegTypeLib);
705 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
706 ITypeLib_Release(pTypeLib);
707 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
714 static IWidget *Widget_Create(void)
717 ITypeInfo *pTypeInfo;
720 pTypeInfo = get_type_info(&IID_IWidget);
724 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
725 This->lpVtbl = &Widget_VTable;
727 This->pDispatchUnknown = NULL;
729 hr = CreateStdDispatch((IUnknown *)&This->lpVtbl, This, pTypeInfo, &This->pDispatchUnknown);
730 ok_ole_success(hr, CreateStdDispatch);
731 ITypeInfo_Release(pTypeInfo);
734 return (IWidget *)&This->lpVtbl;
737 HeapFree(GetProcessHeap(), 0, This);
742 static HRESULT WINAPI KindaEnum_QueryInterface(
743 IKindaEnumWidget *iface,
744 /* [in] */ REFIID riid,
745 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
747 if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
749 IKindaEnumWidget_AddRef(iface);
756 return E_NOINTERFACE;
760 static ULONG WINAPI KindaEnum_AddRef(
761 IKindaEnumWidget *iface)
763 KindaEnum *This = (KindaEnum *)iface;
765 return InterlockedIncrement(&This->refs);
768 static ULONG WINAPI KindaEnum_Release(
769 IKindaEnumWidget *iface)
771 KindaEnum *This = (KindaEnum *)iface;
772 ULONG refs = InterlockedDecrement(&This->refs);
775 memset(This, 0xcc, sizeof(*This));
776 HeapFree(GetProcessHeap(), 0, This);
777 trace("KindaEnumWidget destroyed!\n");
783 static HRESULT WINAPI KindaEnum_Next(
784 IKindaEnumWidget *iface,
785 /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
787 *widget = Widget_Create();
791 return E_OUTOFMEMORY;
794 static HRESULT WINAPI KindaEnum_Count(
795 IKindaEnumWidget *iface,
796 /* [out] */ ULONG __RPC_FAR *count)
801 static HRESULT WINAPI KindaEnum_Reset(
802 IKindaEnumWidget *iface)
807 static HRESULT WINAPI KindaEnum_Clone(
808 IKindaEnumWidget *iface,
809 /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
814 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
816 KindaEnum_QueryInterface,
825 static IKindaEnumWidget *KindaEnumWidget_Create(void)
829 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
830 if (!This) return NULL;
831 This->lpVtbl = &KindaEnumWidget_VTable;
833 return (IKindaEnumWidget *)This;
836 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
838 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
840 *(INonOleAutomation **)ppv = iface;
844 return E_NOINTERFACE;
847 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
852 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
857 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
859 static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
860 return SysAllocString(wszTestString);
863 static INonOleAutomationVtbl NonOleAutomation_VTable =
865 NonOleAutomation_QueryInterface,
866 NonOleAutomation_AddRef,
867 NonOleAutomation_Release,
868 NonOleAutomation_BstrRet,
871 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
873 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
876 HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
877 ok_ole_success(hr, LoadRegTypeLib);
880 ITypeInfo *pTypeInfo;
881 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
882 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
888 static void test_typelibmarshal(void)
890 static const WCHAR szCat[] = { 'C','a','t',0 };
891 static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
892 static WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
894 IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
897 IDispatch *pDispatch;
898 static const LARGE_INTEGER ullZero;
901 DISPID dispidNamed = DISPID_PROPERTYPUT;
902 DISPPARAMS dispparams;
903 VARIANTARG vararg[4];
908 ITypeInfo *pTypeInfo;
910 MYSTRUCT mystructArray[5];
912 ok(pKEW != NULL, "Widget creation failed\n");
914 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
915 ok_ole_success(hr, CreateStreamOnHGlobal);
916 tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
917 IKindaEnumWidget_Release(pKEW);
919 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
920 hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
921 ok_ole_success(hr, CoUnmarshalInterface);
922 IStream_Release(pStream);
924 hr = IKindaEnumWidget_Next(pKEW, &pWidget);
925 ok_ole_success(hr, IKindaEnumWidget_Next);
927 IKindaEnumWidget_Release(pKEW);
929 hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
932 VariantInit(&vararg[0]);
933 dispparams.cNamedArgs = 1;
934 dispparams.rgdispidNamedArgs = &dispidNamed;
935 dispparams.cArgs = 1;
936 dispparams.rgvarg = vararg;
937 VariantInit(&varresult);
938 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
939 ok_ole_success(hr, IDispatch_Invoke);
940 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
941 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
942 excepinfo.wCode, excepinfo.scode);
943 VariantClear(&varresult);
945 /* call put_Name (direct) */
946 bstr = SysAllocString(szSuperman);
947 hr = IWidget_put_Name(pWidget, bstr);
948 ok_ole_success(hr, IWidget_put_Name);
952 dispparams.cNamedArgs = 0;
953 dispparams.rgdispidNamedArgs = NULL;
954 dispparams.cArgs = 0;
955 dispparams.rgvarg = NULL;
956 VariantInit(&varresult);
957 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
958 ok_ole_success(hr, IDispatch_Invoke);
959 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
960 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
961 excepinfo.wCode, excepinfo.scode);
962 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
963 VariantClear(&varresult);
965 /* call get_Name (direct) */
967 hr = IWidget_get_Name(pWidget, &bstr);
968 ok_ole_success(hr, IWidget_get_Name);
969 ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
972 /* call DoSomething */
973 VariantInit(&vararg[0]);
974 VariantInit(&vararg[1]);
975 V_VT(&vararg[1]) = VT_R8;
976 V_R8(&vararg[1]) = 3.141;
977 dispparams.cNamedArgs = 0;
978 dispparams.cArgs = 2;
979 dispparams.rgdispidNamedArgs = NULL;
980 dispparams.rgvarg = vararg;
981 VariantInit(&varresult);
982 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
983 ok_ole_success(hr, IDispatch_Invoke);
984 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
985 VariantClear(&varresult);
988 dispparams.cNamedArgs = 0;
989 dispparams.cArgs = 0;
990 dispparams.rgdispidNamedArgs = NULL;
991 dispparams.rgvarg = NULL;
992 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
993 ok_ole_success(hr, IDispatch_Invoke);
994 ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
996 /* call get_State (direct) */
997 hr = IWidget_get_State(pWidget, &the_state);
998 ok_ole_success(hr, IWidget_get_state);
999 ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
1001 /* call put_State */
1002 the_state = STATE_WIDGETIFIED;
1003 VariantInit(&vararg[0]);
1004 V_VT(&vararg[0]) = VT_BYREF|VT_I4;
1005 V_I4REF(&vararg[0]) = (int *)&the_state;
1006 dispparams.cNamedArgs = 1;
1007 dispparams.cArgs = 1;
1008 dispparams.rgdispidNamedArgs = &dispidNamed;
1009 dispparams.rgvarg = vararg;
1010 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1011 ok_ole_success(hr, IDispatch_Invoke);
1014 bstr = SysAllocString(szTestTest);
1015 VariantInit(&vararg[0]);
1016 V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
1017 V_BSTRREF(&vararg[0]) = &bstr;
1018 dispparams.cNamedArgs = 0;
1019 dispparams.cArgs = 1;
1020 dispparams.rgdispidNamedArgs = NULL;
1021 dispparams.rgvarg = vararg;
1022 VariantInit(&varresult);
1023 hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1024 ok_ole_success(hr, IDispatch_Invoke);
1025 ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
1026 ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1027 VariantClear(&varresult);
1029 /* call SetOleColor with large negative VT_I4 param */
1030 VariantInit(&vararg[0]);
1031 V_VT(&vararg[0]) = VT_I4;
1032 V_I4(&vararg[0]) = 0x80000005;
1033 dispparams.cNamedArgs = 0;
1034 dispparams.cArgs = 1;
1035 dispparams.rgdispidNamedArgs = NULL;
1036 dispparams.rgvarg = vararg;
1037 hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1038 ok_ole_success(hr, IDispatch_Invoke);
1040 /* call GetOleColor */
1041 dispparams.cNamedArgs = 0;
1042 dispparams.cArgs = 0;
1043 dispparams.rgdispidNamedArgs = NULL;
1044 dispparams.rgvarg = NULL;
1045 VariantInit(&varresult);
1046 hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1047 ok_ole_success(hr, IDispatch_Invoke);
1048 VariantClear(&varresult);
1050 /* call StructArgs (direct) */
1051 mystruct = MYSTRUCT_BYPTR;
1052 memcpy(mystructArray, MYSTRUCT_ARRAY, sizeof(mystructArray));
1053 hr = IWidget_StructArgs(pWidget, MYSTRUCT_BYVAL, &mystruct, mystructArray);
1055 ok_ole_success(hr, IWidget_StructArgs);
1059 dispparams.cNamedArgs = 0;
1060 dispparams.cArgs = 0;
1061 dispparams.rgdispidNamedArgs = NULL;
1062 dispparams.rgvarg = NULL;
1063 VariantInit(&varresult);
1064 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1065 ok_ole_success(hr, IDispatch_Invoke);
1066 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1067 VariantClear(&varresult);
1069 /* call CloneInterface */
1070 dispparams.cNamedArgs = 0;
1071 dispparams.cArgs = 0;
1072 dispparams.rgdispidNamedArgs = NULL;
1073 dispparams.rgvarg = NULL;
1074 VariantInit(&varresult);
1075 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1076 ok_ole_success(hr, IDispatch_Invoke);
1077 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1078 VariantClear(&varresult);
1080 /* call CloneDispatch with automatic value getting */
1081 V_VT(&vararg[0]) = VT_I2;
1082 V_I2(&vararg[0]) = 1;
1083 dispparams.cNamedArgs = 0;
1084 dispparams.rgdispidNamedArgs = NULL;
1085 dispparams.cArgs = 1;
1086 dispparams.rgvarg = vararg;
1087 VariantInit(&varresult);
1088 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1089 ok_ole_success(hr, IDispatch_Invoke);
1091 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1092 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1093 excepinfo.wCode, excepinfo.scode);
1095 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1096 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1097 VariantClear(&varresult);
1099 /* call CloneCoclass */
1100 dispparams.cNamedArgs = 0;
1101 dispparams.cArgs = 0;
1102 dispparams.rgdispidNamedArgs = NULL;
1103 dispparams.rgvarg = NULL;
1104 VariantInit(&varresult);
1105 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1106 ok_ole_success(hr, IDispatch_Invoke);
1108 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1109 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1110 excepinfo.wCode, excepinfo.scode);
1112 ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
1113 ok(!V_DISPATCH(&varresult), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult));
1114 VariantClear(&varresult);
1116 /* call Value with a VT_VARIANT|VT_BYREF type */
1117 V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
1118 V_VARIANTREF(&vararg[0]) = &vararg[1];
1119 V_VT(&vararg[1]) = VT_I2;
1120 V_I2(&vararg[1]) = 1;
1121 dispparams.cNamedArgs = 0;
1122 dispparams.rgdispidNamedArgs = NULL;
1123 dispparams.cArgs = 1;
1124 dispparams.rgvarg = vararg;
1125 VariantInit(&varresult);
1126 hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1127 ok_ole_success(hr, IDispatch_Invoke);
1129 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1130 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1131 excepinfo.wCode, excepinfo.scode);
1133 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1134 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1135 VariantClear(&varresult);
1137 /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1138 * handling of void return types */
1139 /* use a big type to ensure that the variant was properly copied into the
1140 * destination function's args */
1141 V_VT(&vararg[0]) = VT_CY;
1142 S(V_CY(&vararg[0])).Hi = 0xdababe;
1143 S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
1144 dispparams.cNamedArgs = 0;
1145 dispparams.cArgs = 1;
1146 dispparams.rgdispidNamedArgs = NULL;
1147 dispparams.rgvarg = vararg;
1148 VariantInit(&varresult);
1149 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1150 ok_ole_success(hr, IDispatch_Invoke);
1151 VariantClear(&varresult);
1154 VariantInit(&vararg[3]);
1155 V_VT(&vararg[3]) = VT_I4;
1156 V_I4(&vararg[3]) = 3;
1157 VariantInit(&vararg[2]);
1158 V_VT(&vararg[2]) = VT_I4;
1159 V_I4(&vararg[2]) = 0;
1160 VariantInit(&vararg[1]);
1161 V_VT(&vararg[1]) = VT_I4;
1162 V_I4(&vararg[1]) = 1;
1163 VariantInit(&vararg[0]);
1164 V_VT(&vararg[0]) = VT_I4;
1165 V_I4(&vararg[0]) = 2;
1166 dispparams.cNamedArgs = 0;
1167 dispparams.cArgs = 4;
1168 dispparams.rgdispidNamedArgs = NULL;
1169 dispparams.rgvarg = vararg;
1170 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1171 ok_ole_success(hr, ITypeInfo_Invoke);
1173 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1175 dispparams.cNamedArgs = 1;
1176 dispparams.rgdispidNamedArgs = &dispidNamed;
1177 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1178 ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
1179 dispidNamed = DISPID_PROPERTYPUT;
1182 dispparams.cNamedArgs = 0;
1183 dispparams.cArgs = 0;
1184 dispparams.rgdispidNamedArgs = NULL;
1185 dispparams.rgvarg = NULL;
1186 VariantInit(&varresult);
1187 hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1188 ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1189 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1190 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1191 excepinfo.wCode, excepinfo.scode);
1192 VariantClear(&varresult);
1195 pTypeInfo = NonOleAutomation_GetTypeInfo();
1196 dispparams.cNamedArgs = 0;
1197 dispparams.cArgs = 0;
1198 dispparams.rgdispidNamedArgs = NULL;
1199 dispparams.rgvarg = NULL;
1200 VariantInit(&varresult);
1201 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1202 ok_ole_success(hr, ITypeInfo_Invoke);
1203 ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
1204 ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
1206 VariantClear(&varresult);
1207 ITypeInfo_Release(pTypeInfo);
1209 /* tests call put_Name without named arg */
1210 VariantInit(&vararg[0]);
1211 dispparams.cNamedArgs = 0;
1212 dispparams.rgdispidNamedArgs = NULL;
1213 dispparams.cArgs = 1;
1214 dispparams.rgvarg = vararg;
1215 VariantInit(&varresult);
1216 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1217 ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
1218 VariantClear(&varresult);
1220 /* tests param type that cannot be coerced */
1221 VariantInit(&vararg[0]);
1222 V_VT(&vararg[0]) = VT_UNKNOWN;
1223 V_UNKNOWN(&vararg[0]) = NULL;
1224 dispparams.cNamedArgs = 1;
1225 dispparams.rgdispidNamedArgs = &dispidNamed;
1226 dispparams.cArgs = 1;
1227 dispparams.rgvarg = vararg;
1228 VariantInit(&varresult);
1229 #if 0 /* NULL unknown not currently marshaled correctly */
1230 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1231 ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1233 VariantClear(&varresult);
1235 /* tests bad param type */
1236 VariantInit(&vararg[0]);
1237 V_VT(&vararg[0]) = VT_CLSID;
1238 V_BYREF(&vararg[0]) = NULL;
1239 dispparams.cNamedArgs = 1;
1240 dispparams.rgdispidNamedArgs = &dispidNamed;
1241 dispparams.cArgs = 1;
1242 dispparams.rgvarg = vararg;
1243 VariantInit(&varresult);
1244 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1245 ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1246 VariantClear(&varresult);
1248 /* tests too small param count */
1249 dispparams.cNamedArgs = 0;
1250 dispparams.rgdispidNamedArgs = NULL;
1251 dispparams.cArgs = 0;
1252 dispparams.rgvarg = NULL;
1253 VariantInit(&varresult);
1254 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1255 ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1256 VariantClear(&varresult);
1258 /* tests propget function with large param count */
1259 VariantInit(&vararg[0]);
1260 V_VT(&vararg[0]) = VT_BSTR;
1261 V_BSTR(&vararg[0]) = NULL;
1262 V_VT(&vararg[1]) = VT_I4;
1263 V_I4(&vararg[1]) = 1;
1264 dispparams.cNamedArgs = 0;
1265 dispparams.cArgs = 2;
1266 dispparams.rgdispidNamedArgs = NULL;
1267 dispparams.rgvarg = vararg;
1268 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1269 ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1271 /* test propput with lcid */
1273 /* the lcid passed to the function is the first lcid in the typelib header.
1274 Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1275 VariantInit(&vararg[0]);
1276 V_VT(&vararg[0]) = VT_I4;
1277 V_I4(&vararg[0]) = 0xcafe;
1278 dispparams.cNamedArgs = 1;
1279 dispparams.rgdispidNamedArgs = &dispidNamed;
1280 dispparams.cArgs = 1;
1281 dispparams.rgvarg = vararg;
1282 VariantInit(&varresult);
1283 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1285 ok_ole_success(hr, ITypeInfo_Invoke);
1286 VariantClear(&varresult);
1288 /* test propget with lcid */
1289 dispparams.cNamedArgs = 0;
1290 dispparams.cArgs = 0;
1291 dispparams.rgvarg = NULL;
1292 dispparams.rgdispidNamedArgs = NULL;
1293 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1296 ok_ole_success(hr, ITypeInfo_Invoke);
1297 ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1298 ok(V_I4(&varresult) == 0x409, "got %x\n", V_I4(&varresult));
1300 VariantClear(&varresult);
1302 IDispatch_Release(pDispatch);
1303 IWidget_Release(pWidget);
1305 trace("calling end_host_object\n");
1306 end_host_object(tid, thread);
1309 static void test_DispCallFunc(void)
1311 static const WCHAR szEmpty[] = { 0 };
1312 VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1313 VARIANTARG vararg[4];
1315 VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1316 VARIANTARG varresult;
1318 IWidget *pWidget = Widget_Create();
1319 V_VT(&vararg[0]) = VT_R8;
1320 V_R8(&vararg[0]) = 3.141;
1321 V_VT(&vararg[1]) = VT_BSTR;
1322 V_BSTR(&vararg[1]) = SysAllocString(szEmpty);
1323 V_VT(&vararg[2]) = VT_BSTR;
1324 V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1325 V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1326 V_VARIANTREF(&vararg[3]) = &varref;
1327 V_VT(&varref) = VT_ERROR;
1328 V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1329 VariantInit(&varresult);
1330 hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1331 ok_ole_success(hr, DispCallFunc);
1332 VariantClear(&varresult);
1333 VariantClear(&vararg[1]);
1334 VariantClear(&vararg[2]);
1335 IWidget_Release(pWidget);
1338 static void test_StaticWidget(void)
1340 ITypeInfo *type_info;
1341 DISPPARAMS dispparams;
1342 VARIANTARG vararg[4];
1343 EXCEPINFO excepinfo;
1347 type_info = get_type_info(&IID_IStaticWidget);
1350 dispparams.cNamedArgs = 0;
1351 dispparams.cArgs = 1;
1352 dispparams.rgdispidNamedArgs = NULL;
1353 dispparams.rgvarg = vararg;
1354 V_VT(vararg) = VT_DISPATCH;
1355 V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1356 VariantInit(&varresult);
1357 hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
1358 &dispparams, &varresult, &excepinfo, NULL);
1359 ok_ole_success(hr, IDispatch_Invoke);
1360 ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1361 VariantClear(&varresult);
1363 ITypeInfo_Release(type_info);
1366 START_TEST(tmarshal)
1370 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1372 hr = register_current_module_typelib();
1373 ok_ole_success(hr, register_current_module_typelib);
1375 test_typelibmarshal();
1376 test_DispCallFunc();
1377 test_StaticWidget();
1379 hr = UnRegisterTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL,
1380 sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
1381 ok_ole_success(hr, UnRegisterTypeLib);