1 /*
2 * Copyright (C) 2005-2006 Robert Shearman for CodeWeavers
3 *
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.
8 *
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.
13 *
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
17 *
18 */
19
20 #define COBJMACROS
21 #define CONST_VTABLE
22
23 #include <windows.h>
24 #include <ocidl.h>
25 #include <stdio.h>
26
27 #include "wine/test.h"
28
29 #include "tmarshal.h"
30 #include "tmarshal_dispids.h"
31
32 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
33
34
35 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", (unsigned long int)hr)
36
37 /* ULL suffix is not portable */
38 #define ULL_CONST(dw1, dw2) ((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)
39
40 const MYSTRUCT MYSTRUCT_BYVAL = {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432), {0,1,2,3,4,5,6,7}};
41 const MYSTRUCT MYSTRUCT_BYPTR = {0x91827364, ULL_CONST(0x88776655, 0x44332211), {0,1,2,3,4,5,6,7}};
42 const MYSTRUCT MYSTRUCT_ARRAY[5] = {
43 {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415), {0,1,2,3,4,5,6,7}},
44 {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425), {0,1,2,3,4,5,6,7}},
45 {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435), {0,1,2,3,4,5,6,7}},
46 {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445), {0,1,2,3,4,5,6,7}},
47 {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455), {0,1,2,3,4,5,6,7}},
48 };
49
50
51 #define RELEASEMARSHALDATA WM_USER
52
53 struct host_object_data
54 {
55 IStream *stream;
56 IID iid;
57 IUnknown *object;
58 MSHLFLAGS marshal_flags;
59 HANDLE marshal_event;
60 IMessageFilter *filter;
61 };
62
63 static DWORD CALLBACK host_object_proc(LPVOID p)
64 {
65 struct host_object_data *data = p;
66 HRESULT hr;
67 MSG msg;
68
69 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
70
71 if (data->filter)
72 {
73 IMessageFilter * prev_filter = NULL;
74 hr = CoRegisterMessageFilter(data->filter, &prev_filter);
75 if (prev_filter) IMessageFilter_Release(prev_filter);
76 ok_ole_success(hr, CoRegisterMessageFilter);
77 }
78
79 hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
80 ok_ole_success(hr, CoMarshalInterface);
81
82 /* force the message queue to be created before signaling parent thread */
83 PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
84
85 SetEvent(data->marshal_event);
86
87 while (GetMessage(&msg, NULL, 0, 0))
88 {
89 if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
90 {
91 trace("releasing marshal data\n");
92 CoReleaseMarshalData(data->stream);
93 SetEvent((HANDLE)msg.lParam);
94 }
95 else
96 DispatchMessage(&msg);
97 }
98
99 HeapFree(GetProcessHeap(), 0, data);
100
101 CoUninitialize();
102
103 return hr;
104 }
105
106 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
107 {
108 DWORD tid = 0;
109 HANDLE marshal_event = CreateEvent(NULL, FALSE, FALSE, NULL);
110 struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
111
112 data->stream = stream;
113 data->iid = *riid;
114 data->object = object;
115 data->marshal_flags = marshal_flags;
116 data->marshal_event = marshal_event;
117 data->filter = filter;
118
119 *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
120
121 /* wait for marshaling to complete before returning */
122 WaitForSingleObject(marshal_event, INFINITE);
123 CloseHandle(marshal_event);
124
125 return tid;
126 }
127
128 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
129 {
130 return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
131 }
132
133 #if 0 /* not used */
134 /* asks thread to release the marshal data because it has to be done by the
135 * same thread that marshaled the interface in the first place. */
136 static void release_host_object(DWORD tid)
137 {
138 HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
139 PostThreadMessage(tid, RELEASEMARSHALDATA, 0, (LPARAM)event);
140 WaitForSingleObject(event, INFINITE);
141 CloseHandle(event);
142 }
143 #endif
144
145 static void end_host_object(DWORD tid, HANDLE thread)
146 {
147 BOOL ret = PostThreadMessage(tid, WM_QUIT, 0, 0);
148 ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
149 /* be careful of races - don't return until hosting thread has terminated */
150 WaitForSingleObject(thread, INFINITE);
151 CloseHandle(thread);
152 }
153
154 static ItestDual TestDual, TestDualDisp;
155
156 static HRESULT WINAPI TestDual_QueryInterface(ItestDual *iface, REFIID riid, void **ppvObject)
157 {
158 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch)) {
159 *ppvObject = &TestDualDisp;
160 return S_OK;
161 }else if(IsEqualGUID(riid, &IID_ItestDual)) {
162 *ppvObject = &TestDual;
163 return S_OK;
164 }
165
166 *ppvObject = NULL;
167 return E_NOINTERFACE;
168 }
169
170 static ULONG WINAPI TestDual_AddRef(ItestDual *iface)
171 {
172 return 2;
173 }
174
175 static ULONG WINAPI TestDual_Release(ItestDual *iface)
176 {
177 return 1;
178 }
179
180 static HRESULT WINAPI TestDual_GetTypeInfoCount(ItestDual *iface, UINT *pctinfo)
181 {
182 ok(0, "unexpected call\n");
183 return E_NOTIMPL;
184 }
185
186 static HRESULT WINAPI TestDual_GetTypeInfo(ItestDual *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
187 {
188 ok(0, "unexpected call\n");
189 return E_NOTIMPL;
190 }
191
192 static HRESULT WINAPI TestDual_GetIDsOfNames(ItestDual *iface, REFIID riid, LPOLESTR *rgszNames,
193 UINT cNames, LCID lcid, DISPID *rgDispId)
194 {
195 ok(0, "unexpected call\n");
196 return E_NOTIMPL;
197 }
198
199 static HRESULT WINAPI TestDual_Invoke(ItestDual *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
200 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
201 UINT *puArgErr)
202 {
203 ok(0, "unexpected call\n");
204 return E_NOTIMPL;
205 }
206
207 static ItestDualVtbl TestDualVtbl = {
208 TestDual_QueryInterface,
209 TestDual_AddRef,
210 TestDual_Release,
211 TestDual_GetTypeInfoCount,
212 TestDual_GetTypeInfo,
213 TestDual_GetIDsOfNames,
214 TestDual_Invoke
215 };
216
217 static ItestDual TestDual = { &TestDualVtbl };
218 static ItestDual TestDualDisp = { &TestDualVtbl };
219
220 typedef struct Widget
221 {
222 IWidget IWidget_iface;
223 LONG refs;
224 IUnknown *pDispatchUnknown;
225 } Widget;
226
227 static inline Widget *impl_from_IWidget(IWidget *iface)
228 {
229 return CONTAINING_RECORD(iface, Widget, IWidget_iface);
230 }
231
232 static HRESULT WINAPI Widget_QueryInterface(
233 IWidget *iface,
234 /* [in] */ REFIID riid,
235 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
236 {
237 if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
238 {
239 IWidget_AddRef(iface);
240 *ppvObject = iface;
241 return S_OK;
242 }
243 else
244 {
245 *ppvObject = NULL;
246 return E_NOINTERFACE;
247 }
248 }
249
250 static ULONG WINAPI Widget_AddRef(
251 IWidget *iface)
252 {
253 Widget *This = impl_from_IWidget(iface);
254
255 return InterlockedIncrement(&This->refs);
256 }
257
258 static ULONG WINAPI Widget_Release(
259 IWidget *iface)
260 {
261 Widget *This = impl_from_IWidget(iface);
262 ULONG refs = InterlockedDecrement(&This->refs);
263 if (!refs)
264 {
265 IUnknown_Release(This->pDispatchUnknown);
266 memset(This, 0xcc, sizeof(*This));
267 HeapFree(GetProcessHeap(), 0, This);
268 trace("Widget destroyed!\n");
269 }
270
271 return refs;
272 }
273
274 static HRESULT WINAPI Widget_GetTypeInfoCount(
275 IWidget *iface,
276 /* [out] */ UINT __RPC_FAR *pctinfo)
277 {
278 Widget *This = impl_from_IWidget(iface);
279 IDispatch *pDispatch;
280 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
281 if (SUCCEEDED(hr))
282 {
283 hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
284 IDispatch_Release(pDispatch);
285 }
286 return hr;
287 }
288
289 static HRESULT WINAPI Widget_GetTypeInfo(
290 IWidget __RPC_FAR * iface,
291 /* [in] */ UINT iTInfo,
292 /* [in] */ LCID lcid,
293 /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
294 {
295 Widget *This = impl_from_IWidget(iface);
296 IDispatch *pDispatch;
297 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
298 if (SUCCEEDED(hr))
299 {
300 hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
301 IDispatch_Release(pDispatch);
302 }
303 return hr;
304 }
305
306 static HRESULT WINAPI Widget_GetIDsOfNames(
307 IWidget __RPC_FAR * iface,
308 /* [in] */ REFIID riid,
309 /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
310 /* [in] */ UINT cNames,
311 /* [in] */ LCID lcid,
312 /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
313 {
314 Widget *This = impl_from_IWidget(iface);
315 IDispatch *pDispatch;
316 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
317 if (SUCCEEDED(hr))
318 {
319 hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
320 IDispatch_Release(pDispatch);
321 }
322 return hr;
323 }
324
325 static HRESULT WINAPI Widget_Invoke(
326 IWidget __RPC_FAR * iface,
327 /* [in] */ DISPID dispIdMember,
328 /* [in] */ REFIID riid,
329 /* [in] */ LCID lcid,
330 /* [in] */ WORD wFlags,
331 /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
332 /* [out] */ VARIANT __RPC_FAR *pVarResult,
333 /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
334 /* [out] */ UINT __RPC_FAR *puArgErr)
335 {
336 Widget *This = impl_from_IWidget(iface);
337 IDispatch *pDispatch;
338 HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
339 if (SUCCEEDED(hr))
340 {
341 hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
342 IDispatch_Release(pDispatch);
343 }
344 return hr;
345 }
346
347 static HRESULT WINAPI Widget_put_Name(
348 IWidget __RPC_FAR * iface,
349 /* [in] */ BSTR name)
350 {
351 trace("put_Name(%s)\n", wine_dbgstr_w(name));
352 return S_OK;
353 }
354
355 static HRESULT WINAPI Widget_get_Name(
356 IWidget __RPC_FAR * iface,
357 /* [out] */ BSTR __RPC_FAR *name)
358 {
359 static const WCHAR szCat[] = { 'C','a','t',0 };
360 trace("get_Name()\n");
361 *name = SysAllocString(szCat);
362 return S_OK;
363 }
364
365 static HRESULT WINAPI Widget_DoSomething(
366 IWidget __RPC_FAR * iface,
367 /* [in] */ double number,
368 /* [out] */ BSTR *str1,
369 /* [defaultvalue][in] */ BSTR str2,
370 /* [optional][in] */ VARIANT __RPC_FAR *opt)
371 {
372 static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
373 trace("DoSomething()\n");
374
375 ok(number == 3.141, "number(%f) != 3.141\n", number);
376 ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
377 ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
378 ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
379 *str1 = SysAllocString(szString);
380
381 return S_FALSE;
382 }
383
384 static HRESULT WINAPI Widget_get_State(
385 IWidget __RPC_FAR * iface,
386 /* [retval][out] */ STATE __RPC_FAR *state)
387 {
388 trace("get_State() = STATE_WIDGETIFIED\n");
389 *state = STATE_WIDGETIFIED;
390 return S_OK;
391 }
392
393 static HRESULT WINAPI Widget_put_State(
394 IWidget __RPC_FAR * iface,
395 /* [in] */ STATE state)
396 {
397 trace("put_State(%d)\n", state);
398 return S_OK;
399 }
400
401 static HRESULT WINAPI Widget_Map(
402 IWidget * iface,
403 BSTR bstrId,
404 BSTR *sValue)
405 {
406 trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
407 *sValue = SysAllocString(bstrId);
408 return S_OK;
409 }
410
411 static HRESULT WINAPI Widget_SetOleColor(
412 IWidget * iface,
413 OLE_COLOR val)
414 {
415 trace("SetOleColor(0x%x)\n", val);
416 return S_OK;
417 }
418
419 static HRESULT WINAPI Widget_GetOleColor(
420 IWidget * iface,
421 OLE_COLOR *pVal)
422 {
423 trace("GetOleColor() = 0x8000000f\n");
424 *pVal = 0x8000000f;
425 return S_FALSE;
426 }
427
428 static HRESULT WINAPI Widget_Clone(
429 IWidget *iface,
430 IWidget **ppVal)
431 {
432 trace("Clone()\n");
433 return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
434 }
435
436 static HRESULT WINAPI Widget_CloneDispatch(
437 IWidget *iface,
438 IDispatch **ppVal)
439 {
440 trace("CloneDispatch()\n");
441 return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
442 }
443
444 static HRESULT WINAPI Widget_CloneCoclass(
445 IWidget *iface,
446 ApplicationObject2 **ppVal)
447 {
448 trace("CloneCoclass()\n");
449 return S_OK;
450 }
451
452 static HRESULT WINAPI Widget_Value(
453 IWidget __RPC_FAR * iface,
454 VARIANT *value,
455 VARIANT *retval)
456 {
457 trace("Value(%p, %p)\n", value, retval);
458 ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
459 ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
460 V_VT(retval) = VT_I2;
461 V_I2(retval) = 1234;
462 return S_OK;
463 }
464
465 static HRESULT WINAPI Widget_Array(
466 IWidget * iface,
467 SAFEARRAY * values)
468 {
469 trace("Array(%p)\n", values);
470 return S_OK;
471 }
472
473 static HRESULT WINAPI Widget_VariantArrayPtr(
474 IWidget * iface,
475 SAFEARRAY ** values)
476 {
477 trace("VariantArrayPtr(%p)\n", values);
478 return S_OK;
479 }
480
481 static HRESULT WINAPI Widget_VariantCArray(
482 IWidget * iface,
483 ULONG count,
484 VARIANT values[])
485 {
486 ULONG i;
487
488 trace("VariantCArray(%u,%p)\n", count, values);
489
490 ok(count == 2, "count is %d\n", count);
491 for (i = 0; i < count; i++)
492 ok(V_VT(&values[i]) == VT_I4, "values[%d] is not VT_I4\n", i);
493
494 if (pVarAdd)
495 {
496 VARIANT inc, res;
497 HRESULT hr;
498
499 V_VT(&inc) = VT_I4;
500 V_I4(&inc) = 1;
501 for (i = 0; i < count; i++) {
502 VariantInit(&res);
503 hr = pVarAdd(&values[i], &inc, &res);
504 if (FAILED(hr)) {
505 ok(0, "VarAdd failed at %u with error 0x%x\n", i, hr);
506 return hr;
507 }
508 hr = VariantCopy(&values[i], &res);
509 if (FAILED(hr)) {
510 ok(0, "VariantCopy failed at %u with error 0x%x\n", i, hr);
511 return hr;
512 }
513 }
514 }
515 else
516 win_skip("VarAdd is not available\n");
517
518 return S_OK;
519 }
520
521 static HRESULT WINAPI Widget_Variant(
522 IWidget __RPC_FAR * iface,
523 VARIANT var)
524 {
525 trace("Variant()\n");
526 ok(V_VT(&var) == VT_CY, "V_VT(&var) was %d\n", V_VT(&var));
527 ok(S(V_CY(&var)).Hi == 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var)).Hi);
528 ok(S(V_CY(&var)).Lo == 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var)).Lo);
529 return S_OK;
530 }
531
532 static HRESULT WINAPI Widget_VarArg(
533 IWidget * iface,
534 int numexpect,
535 SAFEARRAY * values)
536 {
537 LONG lbound, ubound, i;
538 VARIANT * data;
539 HRESULT hr;
540
541 trace("VarArg(%p)\n", values);
542
543 hr = SafeArrayGetLBound(values, 1, &lbound);
544 ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
545 ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
546
547 hr = SafeArrayGetUBound(values, 1, &ubound);
548 ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
549 ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
550
551 hr = SafeArrayAccessData(values, (LPVOID)&data);
552 ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
553
554 for (i=0; i<=ubound-lbound; i++)
555 {
556 ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
557 ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
558 }
559
560 hr = SafeArrayUnaccessData(values);
561 ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
562
563 return S_OK;
564 }
565
566
567 static BOOL mystruct_uint_ordered(UINT uarr[8])
568 {
569 int i;
570 for (i = 0; i < sizeof(uarr) / sizeof(uarr[0]); i++)
571 if (uarr[i] != i)
572 return 0;
573
574 return 1;
575 }
576
577 static HRESULT WINAPI Widget_StructArgs(
578 IWidget * iface,
579 MYSTRUCT byval,
580 MYSTRUCT *byptr,
581 MYSTRUCT arr[5])
582 {
583 int i, diff = 0;
584 ok(byval.field1 == MYSTRUCT_BYVAL.field1 &&
585 byval.field2 == MYSTRUCT_BYVAL.field2 &&
586 mystruct_uint_ordered(byval.uarr),
587 "Struct parameter passed by value corrupted\n");
588 ok(byptr->field1 == MYSTRUCT_BYPTR.field1 &&
589 byptr->field2 == MYSTRUCT_BYPTR.field2 &&
590 mystruct_uint_ordered(byptr->uarr),
591 "Struct parameter passed by pointer corrupted\n");
592 for (i = 0; i < 5; i++)
593 if (arr[i].field1 != MYSTRUCT_ARRAY[i].field1 ||
594 arr[i].field2 != MYSTRUCT_ARRAY[i].field2 ||
595 ! mystruct_uint_ordered(arr[i].uarr))
596 diff++;
597 ok(diff == 0, "Array of structs corrupted\n");
598 return S_OK;
599 }
600
601
602 static HRESULT WINAPI Widget_Error(
603 IWidget __RPC_FAR * iface)
604 {
605 trace("Error()\n");
606 return E_NOTIMPL;
607 }
608
609 static HRESULT WINAPI Widget_CloneInterface(
610 IWidget __RPC_FAR * iface,
611 ISomethingFromDispatch **ppVal)
612 {
613 trace("CloneInterface()\n");
614 *ppVal = 0;
615 return S_OK;
616 }
617
618 static HRESULT WINAPI Widget_put_prop_with_lcid(
619 IWidget* iface, LONG lcid, INT i)
620 {
621 trace("put_prop_with_lcid(%08x, %x)\n", lcid, i);
622 ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
623 ok(i == 0xcafe, "got %08x\n", i);
624 return S_OK;
625 }
626
627 static HRESULT WINAPI Widget_get_prop_with_lcid(
628 IWidget* iface, LONG lcid, INT *i)
629 {
630 trace("get_prop_with_lcid(%08x, %p)\n", lcid, i);
631 ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
632 *i = lcid;
633 return S_OK;
634 }
635
636 static HRESULT WINAPI Widget_get_prop_int(
637 IWidget* iface, INT *i)
638 {
639 trace("get_prop_int(%p)\n", i);
640 *i = -13;
641 return S_OK;
642 }
643
644 static HRESULT WINAPI Widget_get_prop_uint(
645 IWidget* iface, UINT *i)
646 {
647 trace("get_prop_uint(%p)\n", i);
648 *i = 42;
649 return S_OK;
650 }
651
652 static HRESULT WINAPI Widget_ByRefUInt(
653 IWidget* iface, UINT *i)
654 {
655 *i = 42;
656 return S_OK;
657 }
658
659 static HRESULT WINAPI Widget_put_prop_opt_arg(
660 IWidget* iface, INT opt, INT i)
661 {
662 trace("put_prop_opt_arg(%08x, %08x)\n", opt, i);
663 todo_wine ok(opt == 0, "got opt=%08x\n", opt);
664 ok(i == 0xcafe, "got i=%08x\n", i);
665 return S_OK;
666 }
667
668 static HRESULT WINAPI Widget_put_prop_req_arg(
669 IWidget* iface, INT req, INT i)
670 {
671 trace("put_prop_req_arg(%08x, %08x)\n", req, i);
672 ok(req == 0x5678, "got req=%08x\n", req);
673 ok(i == 0x1234, "got i=%08x\n", i);
674 return S_OK;
675 }
676
677 static HRESULT WINAPI Widget_restrict(IWidget* iface, INT *i)
678 {
679 trace("restrict\n");
680 *i = DISPID_TM_RESTRICTED;
681 return S_OK;
682 }
683
684 static HRESULT WINAPI Widget_neg_restrict(IWidget* iface, INT *i)
685 {
686 trace("neg_restrict\n");
687 *i = DISPID_TM_NEG_RESTRICTED;
688 return S_OK;
689 }
690
691 static const struct IWidgetVtbl Widget_VTable =
692 {
693 Widget_QueryInterface,
694 Widget_AddRef,
695 Widget_Release,
696 Widget_GetTypeInfoCount,
697 Widget_GetTypeInfo,
698 Widget_GetIDsOfNames,
699 Widget_Invoke,
700 Widget_put_Name,
701 Widget_get_Name,
702 Widget_DoSomething,
703 Widget_get_State,
704 Widget_put_State,
705 Widget_Map,
706 Widget_SetOleColor,
707 Widget_GetOleColor,
708 Widget_Clone,
709 Widget_CloneDispatch,
710 Widget_CloneCoclass,
711 Widget_Value,
712 Widget_Array,
713 Widget_VariantArrayPtr,
714 Widget_VariantCArray,
715 Widget_Variant,
716 Widget_VarArg,
717 Widget_StructArgs,
718 Widget_Error,
719 Widget_CloneInterface,
720 Widget_put_prop_with_lcid,
721 Widget_get_prop_with_lcid,
722 Widget_get_prop_int,
723 Widget_get_prop_uint,
724 Widget_ByRefUInt,
725 Widget_put_prop_opt_arg,
726 Widget_put_prop_req_arg,
727 Widget_restrict,
728 Widget_neg_restrict
729 };
730
731 static HRESULT WINAPI StaticWidget_QueryInterface(IStaticWidget *iface, REFIID riid, void **ppvObject)
732 {
733 if (IsEqualIID(riid, &IID_IStaticWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
734 {
735 IStaticWidget_AddRef(iface);
736 *ppvObject = iface;
737 return S_OK;
738 }
739
740 *ppvObject = NULL;
741 return E_NOINTERFACE;
742 }
743
744 static ULONG WINAPI StaticWidget_AddRef(IStaticWidget *iface)
745 {
746 return 2;
747 }
748
749 static ULONG WINAPI StaticWidget_Release(IStaticWidget *iface)
750 {
751 return 1;
752 }
753
754 static HRESULT WINAPI StaticWidget_GetTypeInfoCount(IStaticWidget *iface, UINT *pctinfo)
755 {
756 ok(0, "unexpected call\n");
757 return E_NOTIMPL;
758 }
759
760 static HRESULT WINAPI StaticWidget_GetTypeInfo(IStaticWidget *iface, UINT iTInfo, LCID lcid,
761 ITypeInfo **ppTInfo)
762 {
763 ok(0, "unexpected call\n");
764 return E_NOTIMPL;
765 }
766
767 static HRESULT WINAPI StaticWidget_GetIDsOfNames(IStaticWidget *iface, REFIID riid, LPOLESTR *rgszNames,
768 UINT cNames, LCID lcid, DISPID *rgDispId)
769 {
770 ok(0, "unexpected call\n");
771 return E_NOTIMPL;
772 }
773
774 static HRESULT WINAPI StaticWidget_Invoke(IStaticWidget *iface, DISPID dispIdMember, REFIID riid,
775 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
776 UINT *puArgErr)
777 {
778 ok(0, "unexpected call\n");
779 return E_NOTIMPL;
780 }
781
782 static HRESULT WINAPI StaticWidget_TestDual(IStaticWidget *iface, ItestDual *p)
783 {
784 trace("TestDual()\n");
785 todo_wine
786 ok(p == &TestDual, "wrong ItestDual\n");
787 return S_OK;
788 }
789
790 static const IStaticWidgetVtbl StaticWidgetVtbl = {
791 StaticWidget_QueryInterface,
792 StaticWidget_AddRef,
793 StaticWidget_Release,
794 StaticWidget_GetTypeInfoCount,
795 StaticWidget_GetTypeInfo,
796 StaticWidget_GetIDsOfNames,
797 StaticWidget_Invoke,
798 StaticWidget_TestDual
799 };
800
801 static IStaticWidget StaticWidget = { &StaticWidgetVtbl };
802
803 typedef struct KindaEnum
804 {
805 IKindaEnumWidget IKindaEnumWidget_iface;
806 LONG refs;
807 } KindaEnum;
808
809 static inline KindaEnum *impl_from_IKindaEnumWidget(IKindaEnumWidget *iface)
810 {
811 return CONTAINING_RECORD(iface, KindaEnum, IKindaEnumWidget_iface);
812 }
813
814 static HRESULT register_current_module_typelib(void)
815 {
816 WCHAR path[MAX_PATH];
817 CHAR pathA[MAX_PATH];
818 HRESULT hr;
819 ITypeLib *typelib;
820
821 GetModuleFileNameA(NULL, pathA, MAX_PATH);
822 MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
823
824 hr = LoadTypeLib(path, &typelib);
825 if (SUCCEEDED(hr))
826 {
827 hr = RegisterTypeLib(typelib, path, NULL);
828 ITypeLib_Release(typelib);
829 }
830 return hr;
831 }
832
833 static ITypeInfo *get_type_info(REFIID riid)
834 {
835 ITypeInfo *pTypeInfo;
836 ITypeLib *pTypeLib;
837 HRESULT hr;
838
839 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
840 ok_ole_success(hr, LoadRegTypeLib);
841 if (FAILED(hr))
842 return NULL;
843
844 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
845 ITypeLib_Release(pTypeLib);
846 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
847 if (FAILED(hr))
848 return NULL;
849
850 return pTypeInfo;
851 }
852
853 static IWidget *Widget_Create(void)
854 {
855 Widget *This;
856 ITypeInfo *pTypeInfo;
857 HRESULT hr = E_FAIL;
858
859 pTypeInfo = get_type_info(&IID_IWidget);
860 if(!pTypeInfo)
861 return NULL;
862
863 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
864 This->IWidget_iface.lpVtbl = &Widget_VTable;
865 This->refs = 1;
866 This->pDispatchUnknown = NULL;
867
868 hr = CreateStdDispatch((IUnknown *)&This->IWidget_iface, This, pTypeInfo,
869 &This->pDispatchUnknown);
870 ok_ole_success(hr, CreateStdDispatch);
871 ITypeInfo_Release(pTypeInfo);
872
873 if (SUCCEEDED(hr))
874 return &This->IWidget_iface;
875 else
876 {
877 HeapFree(GetProcessHeap(), 0, This);
878 return NULL;
879 }
880 }
881
882 static HRESULT WINAPI KindaEnum_QueryInterface(
883 IKindaEnumWidget *iface,
884 /* [in] */ REFIID riid,
885 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
886 {
887 if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
888 {
889 IKindaEnumWidget_AddRef(iface);
890 *ppvObject = iface;
891 return S_OK;
892 }
893 else
894 {
895 *ppvObject = NULL;
896 return E_NOINTERFACE;
897 }
898 }
899
900 static ULONG WINAPI KindaEnum_AddRef(
901 IKindaEnumWidget *iface)
902 {
903 KindaEnum *This = impl_from_IKindaEnumWidget(iface);
904
905 return InterlockedIncrement(&This->refs);
906 }
907
908 static ULONG WINAPI KindaEnum_Release(
909 IKindaEnumWidget *iface)
910 {
911 KindaEnum *This = impl_from_IKindaEnumWidget(iface);
912 ULONG refs = InterlockedDecrement(&This->refs);
913 if (!refs)
914 {
915 memset(This, 0xcc, sizeof(*This));
916 HeapFree(GetProcessHeap(), 0, This);
917 trace("KindaEnumWidget destroyed!\n");
918 }
919
920 return refs;
921 }
922
923 static HRESULT WINAPI KindaEnum_Next(
924 IKindaEnumWidget *iface,
925 /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
926 {
927 *widget = Widget_Create();
928 if (*widget)
929 return S_OK;
930 else
931 return E_OUTOFMEMORY;
932 }
933
934 static HRESULT WINAPI KindaEnum_Count(
935 IKindaEnumWidget *iface,
936 /* [out] */ ULONG __RPC_FAR *count)
937 {
938 return E_NOTIMPL;
939 }
940
941 static HRESULT WINAPI KindaEnum_Reset(
942 IKindaEnumWidget *iface)
943 {
944 return E_NOTIMPL;
945 }
946
947 static HRESULT WINAPI KindaEnum_Clone(
948 IKindaEnumWidget *iface,
949 /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
950 {
951 return E_NOTIMPL;
952 }
953
954 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
955 {
956 KindaEnum_QueryInterface,
957 KindaEnum_AddRef,
958 KindaEnum_Release,
959 KindaEnum_Next,
960 KindaEnum_Count,
961 KindaEnum_Reset,
962 KindaEnum_Clone
963 };
964
965 static IKindaEnumWidget *KindaEnumWidget_Create(void)
966 {
967 KindaEnum *This;
968
969 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
970 if (!This) return NULL;
971 This->IKindaEnumWidget_iface.lpVtbl = &KindaEnumWidget_VTable;
972 This->refs = 1;
973 return &This->IKindaEnumWidget_iface;
974 }
975
976 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
977 {
978 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
979 {
980 *(INonOleAutomation **)ppv = iface;
981 return S_OK;
982 }
983 *ppv = NULL;
984 return E_NOINTERFACE;
985 }
986
987 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
988 {
989 return 2;
990 }
991
992 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
993 {
994 return 1;
995 }
996
997 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
998 {
999 static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
1000 return SysAllocString(wszTestString);
1001 }
1002
1003 static HRESULT WINAPI NonOleAutomation_Error(INonOleAutomation *iface)
1004 {
1005 return E_NOTIMPL;
1006 }
1007
1008 static INonOleAutomationVtbl NonOleAutomation_VTable =
1009 {
1010 NonOleAutomation_QueryInterface,
1011 NonOleAutomation_AddRef,
1012 NonOleAutomation_Release,
1013 NonOleAutomation_BstrRet,
1014 NonOleAutomation_Error
1015 };
1016
1017 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
1018
1019 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
1020 {
1021 ITypeLib *pTypeLib;
1022 HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
1023 ok_ole_success(hr, LoadRegTypeLib);
1024 if (SUCCEEDED(hr))
1025 {
1026 ITypeInfo *pTypeInfo;
1027 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
1028 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1029 ITypeLib_Release(pTypeLib);
1030 return pTypeInfo;
1031 }
1032 return NULL;
1033 }
1034
1035 static void test_typelibmarshal(void)
1036 {
1037 static const WCHAR szCat[] = { 'C','a','t',0 };
1038 static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
1039 static WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
1040 HRESULT hr;
1041 IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
1042 IWidget *pWidget;
1043 IStream *pStream;
1044 IDispatch *pDispatch;
1045 static const LARGE_INTEGER ullZero;
1046 EXCEPINFO excepinfo;
1047 VARIANT varresult;
1048 DISPID dispidNamed = DISPID_PROPERTYPUT;
1049 DISPPARAMS dispparams;
1050 VARIANTARG vararg[4];
1051 STATE the_state;
1052 HANDLE thread;
1053 DWORD tid;
1054 BSTR bstr;
1055 ITypeInfo *pTypeInfo;
1056 MYSTRUCT mystruct;
1057 MYSTRUCT mystructArray[5];
1058 UINT uval;
1059
1060 ok(pKEW != NULL, "Widget creation failed\n");
1061
1062 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1063 ok_ole_success(hr, CreateStreamOnHGlobal);
1064 tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
1065 IKindaEnumWidget_Release(pKEW);
1066
1067 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1068 hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
1069 ok_ole_success(hr, CoUnmarshalInterface);
1070 IStream_Release(pStream);
1071
1072 hr = IKindaEnumWidget_Next(pKEW, &pWidget);
1073 ok_ole_success(hr, IKindaEnumWidget_Next);
1074
1075 IKindaEnumWidget_Release(pKEW);
1076
1077 /* call GetTypeInfoCount (direct) */
1078 hr = IWidget_GetTypeInfoCount(pWidget, &uval);
1079 ok_ole_success(hr, IWidget_GetTypeInfoCount);
1080 hr = IWidget_GetTypeInfoCount(pWidget, &uval);
1081 ok_ole_success(hr, IWidget_GetTypeInfoCount);
1082
1083 hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
1084 ok_ole_success(hr, IWidget_QueryInterface);
1085
1086 /* call put_Name */
1087 VariantInit(&vararg[0]);
1088 dispparams.cNamedArgs = 1;
1089 dispparams.rgdispidNamedArgs = &dispidNamed;
1090 dispparams.cArgs = 1;
1091 dispparams.rgvarg = vararg;
1092 VariantInit(&varresult);
1093 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1094 ok_ole_success(hr, IDispatch_Invoke);
1095 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1096 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1097 excepinfo.wCode, excepinfo.scode);
1098 VariantClear(&varresult);
1099
1100 /* call put_Name (direct) */
1101 bstr = SysAllocString(szSuperman);
1102 hr = IWidget_put_Name(pWidget, bstr);
1103 ok_ole_success(hr, IWidget_put_Name);
1104 SysFreeString(bstr);
1105
1106 /* call get_Name */
1107 dispparams.cNamedArgs = 0;
1108 dispparams.rgdispidNamedArgs = NULL;
1109 dispparams.cArgs = 0;
1110 dispparams.rgvarg = NULL;
1111 VariantInit(&varresult);
1112 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1113 ok_ole_success(hr, IDispatch_Invoke);
1114 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1115 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1116 excepinfo.wCode, excepinfo.scode);
1117 trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1118 VariantClear(&varresult);
1119
1120 /* call get_Name (direct) */
1121 bstr = (void *)0xdeadbeef;
1122 hr = IWidget_get_Name(pWidget, &bstr);
1123 ok_ole_success(hr, IWidget_get_Name);
1124 ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
1125 SysFreeString(bstr);
1126
1127 /* call DoSomething */
1128 VariantInit(&vararg[0]);
1129 VariantInit(&vararg[1]);
1130 V_VT(&vararg[1]) = VT_R8;
1131 V_R8(&vararg[1]) = 3.141;
1132 dispparams.cNamedArgs = 0;
1133 dispparams.cArgs = 2;
1134 dispparams.rgdispidNamedArgs = NULL;
1135 dispparams.rgvarg = vararg;
1136 VariantInit(&varresult);
1137 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1138 ok_ole_success(hr, IDispatch_Invoke);
1139 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1140 VariantClear(&varresult);
1141
1142 /* call get_State */
1143 dispparams.cNamedArgs = 0;
1144 dispparams.cArgs = 0;
1145 dispparams.rgdispidNamedArgs = NULL;
1146 dispparams.rgvarg = NULL;
1147 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1148 ok_ole_success(hr, IDispatch_Invoke);
1149 ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
1150
1151 /* call get_State (direct) */
1152 hr = IWidget_get_State(pWidget, &the_state);
1153 ok_ole_success(hr, IWidget_get_state);
1154 ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
1155
1156 /* call put_State */
1157 the_state = STATE_WIDGETIFIED;
1158 VariantInit(&vararg[0]);
1159 V_VT(&vararg[0]) = VT_BYREF|VT_I4;
1160 V_I4REF(&vararg[0]) = (int *)&the_state;
1161 dispparams.cNamedArgs = 1;
1162 dispparams.cArgs = 1;
1163 dispparams.rgdispidNamedArgs = &dispidNamed;
1164 dispparams.rgvarg = vararg;
1165 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1166 ok_ole_success(hr, IDispatch_Invoke);
1167
1168 /* call Map */
1169 bstr = SysAllocString(szTestTest);
1170 VariantInit(&vararg[0]);
1171 V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
1172 V_BSTRREF(&vararg[0]) = &bstr;
1173 dispparams.cNamedArgs = 0;
1174 dispparams.cArgs = 1;
1175 dispparams.rgdispidNamedArgs = NULL;
1176 dispparams.rgvarg = vararg;
1177 VariantInit(&varresult);
1178 hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1179 ok_ole_success(hr, IDispatch_Invoke);
1180 ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
1181 ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1182 VariantClear(&varresult);
1183 SysFreeString(bstr);
1184
1185 /* call SetOleColor with large negative VT_I4 param */
1186 VariantInit(&vararg[0]);
1187 V_VT(&vararg[0]) = VT_I4;
1188 V_I4(&vararg[0]) = 0x80000005;
1189 dispparams.cNamedArgs = 0;
1190 dispparams.cArgs = 1;
1191 dispparams.rgdispidNamedArgs = NULL;
1192 dispparams.rgvarg = vararg;
1193 hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1194 ok_ole_success(hr, IDispatch_Invoke);
1195
1196 /* call GetOleColor */
1197 dispparams.cNamedArgs = 0;
1198 dispparams.cArgs = 0;
1199 dispparams.rgdispidNamedArgs = NULL;
1200 dispparams.rgvarg = NULL;
1201 VariantInit(&varresult);
1202 hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1203 ok_ole_success(hr, IDispatch_Invoke);
1204 VariantClear(&varresult);
1205
1206 /* call StructArgs (direct) */
1207 mystruct = MYSTRUCT_BYPTR;
1208 memcpy(mystructArray, MYSTRUCT_ARRAY, sizeof(mystructArray));
1209 hr = IWidget_StructArgs(pWidget, MYSTRUCT_BYVAL, &mystruct, mystructArray);
1210 ok_ole_success(hr, IWidget_StructArgs);
1211
1212 /* call Clone */
1213 dispparams.cNamedArgs = 0;
1214 dispparams.cArgs = 0;
1215 dispparams.rgdispidNamedArgs = NULL;
1216 dispparams.rgvarg = NULL;
1217 VariantInit(&varresult);
1218 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1219 ok_ole_success(hr, IDispatch_Invoke);
1220 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1221 VariantClear(&varresult);
1222
1223 /* call CloneInterface */
1224 dispparams.cNamedArgs = 0;
1225 dispparams.cArgs = 0;
1226 dispparams.rgdispidNamedArgs = NULL;
1227 dispparams.rgvarg = NULL;
1228 VariantInit(&varresult);
1229 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1230 ok_ole_success(hr, IDispatch_Invoke);
1231 ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1232 VariantClear(&varresult);
1233
1234 /* call CloneDispatch with automatic value getting */
1235 V_VT(&vararg[0]) = VT_I2;
1236 V_I2(&vararg[0]) = 1;
1237 dispparams.cNamedArgs = 0;
1238 dispparams.rgdispidNamedArgs = NULL;
1239 dispparams.cArgs = 1;
1240 dispparams.rgvarg = vararg;
1241 VariantInit(&varresult);
1242 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1243 ok_ole_success(hr, IDispatch_Invoke);
1244
1245 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1246 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1247 excepinfo.wCode, excepinfo.scode);
1248
1249 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1250 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1251 VariantClear(&varresult);
1252
1253 /* call CloneCoclass */
1254 dispparams.cNamedArgs = 0;
1255 dispparams.cArgs = 0;
1256 dispparams.rgdispidNamedArgs = NULL;
1257 dispparams.rgvarg = NULL;
1258 VariantInit(&varresult);
1259 hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1260 ok_ole_success(hr, IDispatch_Invoke);
1261
1262 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1263 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1264 excepinfo.wCode, excepinfo.scode);
1265
1266 ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
1267 ok(!V_DISPATCH(&varresult), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult));
1268 VariantClear(&varresult);
1269
1270 /* call Value with a VT_VARIANT|VT_BYREF type */
1271 V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
1272 V_VARIANTREF(&vararg[0]) = &vararg[1];
1273 V_VT(&vararg[1]) = VT_I2;
1274 V_I2(&vararg[1]) = 1;
1275 dispparams.cNamedArgs = 0;
1276 dispparams.rgdispidNamedArgs = NULL;
1277 dispparams.cArgs = 1;
1278 dispparams.rgvarg = vararg;
1279 VariantInit(&varresult);
1280 hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1281 ok_ole_success(hr, IDispatch_Invoke);
1282
1283 ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1284 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1285 excepinfo.wCode, excepinfo.scode);
1286
1287 ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1288 ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1289 VariantClear(&varresult);
1290
1291 /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1292 * handling of void return types */
1293 /* use a big type to ensure that the variant was properly copied into the
1294 * destination function's args */
1295 V_VT(&vararg[0]) = VT_CY;
1296 S(V_CY(&vararg[0])).Hi = 0xdababe;
1297 S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
1298 dispparams.cNamedArgs = 0;
1299 dispparams.cArgs = 1;
1300 dispparams.rgdispidNamedArgs = NULL;
1301 dispparams.rgvarg = vararg;
1302 VariantInit(&varresult);
1303 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1304 ok_ole_success(hr, IDispatch_Invoke);
1305 VariantClear(&varresult);
1306
1307 /* call VariantCArray - test marshaling of variant arrays */
1308 V_VT(&vararg[0]) = VT_I4;
1309 V_I4(&vararg[0]) = 1;
1310 V_VT(&vararg[1]) = VT_I4;
1311 V_I4(&vararg[1]) = 2;
1312 hr = IWidget_VariantCArray(pWidget, 2, vararg);
1313 ok_ole_success(hr, IWidget_VariantCArray);
1314 todo_wine
1315 ok(V_VT(&vararg[0]) == VT_I4 && V_I4(&vararg[0]) == 2, "vararg[0] = %d[%d]\n", V_VT(&vararg[0]), V_I4(&vararg[0]));
1316 todo_wine
1317 ok(V_VT(&vararg[1]) == VT_I4 && V_I4(&vararg[1]) == 3, "vararg[1] = %d[%d]\n", V_VT(&vararg[1]), V_I4(&vararg[1]));
1318
1319 /* call VarArg */
1320 VariantInit(&vararg[3]);
1321 V_VT(&vararg[3]) = VT_I4;
1322 V_I4(&vararg[3]) = 3;
1323 VariantInit(&vararg[2]);
1324 V_VT(&vararg[2]) = VT_I4;
1325 V_I4(&vararg[2]) = 0;
1326 VariantInit(&vararg[1]);
1327 V_VT(&vararg[1]) = VT_I4;
1328 V_I4(&vararg[1]) = 1;
1329 VariantInit(&vararg[0]);
1330 V_VT(&vararg[0]) = VT_I4;
1331 V_I4(&vararg[0]) = 2;
1332 dispparams.cNamedArgs = 0;
1333 dispparams.cArgs = 4;
1334 dispparams.rgdispidNamedArgs = NULL;
1335 dispparams.rgvarg = vararg;
1336 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1337 ok_ole_success(hr, ITypeInfo_Invoke);
1338
1339 /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1340 dispidNamed = 0;
1341 dispparams.cNamedArgs = 1;
1342 dispparams.rgdispidNamedArgs = &dispidNamed;
1343 hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1344 ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
1345 dispidNamed = DISPID_PROPERTYPUT;
1346
1347 /* call Error */
1348 dispparams.cNamedArgs = 0;
1349 dispparams.cArgs = 0;
1350 dispparams.rgdispidNamedArgs = NULL;
1351 dispparams.rgvarg = NULL;
1352 VariantInit(&varresult);
1353 hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1354 ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1355 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1356 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1357 excepinfo.wCode, excepinfo.scode);
1358 VariantClear(&varresult);
1359
1360 /* call BstrRet */
1361 pTypeInfo = NonOleAutomation_GetTypeInfo();
1362 dispparams.cNamedArgs = 0;
1363 dispparams.cArgs = 0;
1364 dispparams.rgdispidNamedArgs = NULL;
1365 dispparams.rgvarg = NULL;
1366 VariantInit(&varresult);
1367 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1368 ok_ole_success(hr, ITypeInfo_Invoke);
1369 ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
1370 ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
1371
1372 VariantClear(&varresult);
1373
1374 dispparams.cNamedArgs = 0;
1375 dispparams.cArgs = 0;
1376 dispparams.rgdispidNamedArgs = NULL;
1377 dispparams.rgvarg = NULL;
1378 hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_ERROR, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1379 ok(hr == DISP_E_EXCEPTION, "ITypeInfo_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1380 ok(V_VT(&varresult) == VT_EMPTY, "V_VT(&varresult) should be VT_EMPTY instead of %d\n", V_VT(&varresult));
1381 ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1382 "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1383 excepinfo.wCode, excepinfo.scode);
1384 VariantClear(&varresult);
1385
1386 ITypeInfo_Release(pTypeInfo);
1387
1388 /* tests call put_Name without named arg */
1389 VariantInit(&vararg[0]);
1390 dispparams.cNamedArgs = 0;
1391 dispparams.rgdispidNamedArgs = NULL;
1392 dispparams.cArgs = 1;
1393 dispparams.rgvarg = vararg;
1394 VariantInit(&varresult);
1395 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1396 ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
1397 VariantClear(&varresult);
1398
1399 /* tests param type that cannot be coerced */
1400 VariantInit(&vararg[0]);
1401 V_VT(&vararg[0]) = VT_UNKNOWN;
1402 V_UNKNOWN(&vararg[0]) = NULL;
1403 dispparams.cNamedArgs = 1;
1404 dispparams.rgdispidNamedArgs = &dispidNamed;
1405 dispparams.cArgs = 1;
1406 dispparams.rgvarg = vararg;
1407 VariantInit(&varresult);
1408 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1409 ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1410 VariantClear(&varresult);
1411
1412 /* tests bad param type */
1413 VariantInit(&vararg[0]);
1414 V_VT(&vararg[0]) = VT_CLSID;
1415 V_BYREF(&vararg[0]) = NULL;
1416 dispparams.cNamedArgs = 1;
1417 dispparams.rgdispidNamedArgs = &dispidNamed;
1418 dispparams.cArgs = 1;
1419 dispparams.rgvarg = vararg;
1420 VariantInit(&varresult);
1421 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1422 ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1423 VariantClear(&varresult);
1424
1425 /* tests too small param count */
1426 dispparams.cNamedArgs = 0;
1427 dispparams.rgdispidNamedArgs = NULL;
1428 dispparams.cArgs = 0;
1429 dispparams.rgvarg = NULL;
1430 VariantInit(&varresult);
1431 hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1432 ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1433 VariantClear(&varresult);
1434
1435 /* tests propget function with large param count */
1436 VariantInit(&vararg[0]);
1437 V_VT(&vararg[0]) = VT_BSTR;
1438 V_BSTR(&vararg[0]) = NULL;
1439 V_VT(&vararg[1]) = VT_I4;
1440 V_I4(&vararg[1]) = 1;
1441 dispparams.cNamedArgs = 0;
1442 dispparams.cArgs = 2;
1443 dispparams.rgdispidNamedArgs = NULL;
1444 dispparams.rgvarg = vararg;
1445 hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1446 ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1447
1448 /* test propput with lcid */
1449
1450 /* the lcid passed to the function is the first lcid in the typelib header.
1451 Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1452 VariantInit(&vararg[0]);
1453 V_VT(&vararg[0]) = VT_I4;
1454 V_I4(&vararg[0]) = 0xcafe;
1455 dispparams.cNamedArgs = 1;
1456 dispparams.rgdispidNamedArgs = &dispidNamed;
1457 dispparams.cArgs = 1;
1458 dispparams.rgvarg = vararg;
1459 VariantInit(&varresult);
1460 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1461 ok_ole_success(hr, ITypeInfo_Invoke);
1462 VariantClear(&varresult);
1463
1464 /* test propget with lcid */
1465 dispparams.cNamedArgs = 0;
1466 dispparams.cArgs = 0;
1467 dispparams.rgvarg = NULL;
1468 dispparams.rgdispidNamedArgs = NULL;
1469 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1470 ok_ole_success(hr, ITypeInfo_Invoke);
1471 ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1472 ok(V_I4(&varresult) == 0x409, "got %x\n", V_I4(&varresult));
1473 VariantClear(&varresult);
1474
1475 /* test propget of INT value */
1476 dispparams.cNamedArgs = 0;
1477 dispparams.cArgs = 0;
1478 dispparams.rgvarg = NULL;
1479 dispparams.rgdispidNamedArgs = NULL;
1480 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_INT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1481 ok_ole_success(hr, ITypeInfo_Invoke);
1482 ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1483 ok(V_I4(&varresult) == -13, "got %x\n", V_I4(&varresult));
1484 VariantClear(&varresult);
1485
1486 /* test propget of INT value */
1487 dispparams.cNamedArgs = 0;
1488 dispparams.cArgs = 0;
1489 dispparams.rgvarg = NULL;
1490 dispparams.rgdispidNamedArgs = NULL;
1491 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_UINT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1492 ok_ole_success(hr, ITypeInfo_Invoke);
1493 ok(V_VT(&varresult) == VT_UI4, "got %x\n", V_VT(&varresult));
1494 ok(V_UI4(&varresult) == 42, "got %x\n", V_UI4(&varresult));
1495 VariantClear(&varresult);
1496
1497 /* test byref marshalling */
1498 uval = 666;
1499 VariantInit(&vararg[0]);
1500 V_VT(&vararg[0]) = VT_UI4|VT_BYREF;
1501 V_UI4REF(&vararg[0]) = &uval;
1502 dispparams.cNamedArgs = 0;
1503 dispparams.cArgs = 1;
1504 dispparams.rgvarg = vararg;
1505 dispparams.rgdispidNamedArgs = NULL;
1506 hr = IDispatch_Invoke(pDispatch, DISPID_TM_BYREF_UINT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1507 ok_ole_success(hr, ITypeInfo_Invoke);
1508 ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1509 ok(V_VT(&vararg[0]) == (VT_UI4|VT_BYREF), "arg VT not unmarshalled correctly: %x\n", V_VT(&vararg[0]));
1510 ok(V_UI4REF(&vararg[0]) == &uval, "Byref pointer not preserved: %p/%p\n", &uval, V_UI4REF(&vararg[0]));
1511 ok(*V_UI4REF(&vararg[0]) == 42, "Expected 42 to be returned instead of %u\n", *V_UI4REF(&vararg[0]));
1512 VariantClear(&varresult);
1513 VariantClear(&vararg[0]);
1514
1515 /* test propput with optional argument. */
1516 VariantInit(&vararg[0]);
1517 V_VT(&vararg[0]) = VT_I4;
1518 V_I4(&vararg[0]) = 0xcafe;
1519 dispparams.cNamedArgs = 1;
1520 dispparams.rgdispidNamedArgs = &dispidNamed;
1521 dispparams.cArgs = 1;
1522 dispparams.rgvarg = vararg;
1523 VariantInit(&varresult);
1524 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_OPT_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1525 ok_ole_success(hr, ITypeInfo_Invoke);
1526 VariantClear(&varresult);
1527
1528 /* test propput with required argument. */
1529 VariantInit(&vararg[0]);
1530 VariantInit(&vararg[1]);
1531 V_VT(&vararg[0]) = VT_I4;
1532 V_I4(&vararg[0]) = 0x1234;
1533 V_VT(&vararg[1]) = VT_I4;
1534 V_I4(&vararg[1]) = 0x5678;
1535 dispparams.cNamedArgs = 1;
1536 dispparams.rgdispidNamedArgs = &dispidNamed;
1537 dispparams.cArgs = 2;
1538 dispparams.rgvarg = vararg;
1539 VariantInit(&varresult);
1540 hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_REQ_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1541 ok_ole_success(hr, ITypeInfo_Invoke);
1542 VariantClear(&varresult);
1543
1544 /* restricted member */
1545 dispparams.cNamedArgs = 0;
1546 dispparams.rgdispidNamedArgs = NULL;
1547 dispparams.cArgs = 0;
1548 dispparams.rgvarg = NULL;
1549 VariantInit(&varresult);
1550 hr = IDispatch_Invoke(pDispatch, DISPID_TM_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1551 ok( hr == DISP_E_MEMBERNOTFOUND, "got %08x\n", hr );
1552 VariantClear(&varresult);
1553
1554 /* restricted member with -ve memid (not restricted) */
1555 dispparams.cNamedArgs = 0;
1556 dispparams.rgdispidNamedArgs = NULL;
1557 dispparams.cArgs = 0;
1558 dispparams.rgvarg = NULL;
1559 VariantInit(&varresult);
1560 hr = IDispatch_Invoke(pDispatch, DISPID_TM_NEG_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1561 ok( hr == S_OK, "got %08x\n", hr );
1562 ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1563 ok(V_I4(&varresult) == DISPID_TM_NEG_RESTRICTED, "got %x\n", V_I4(&varresult));
1564 VariantClear(&varresult);
1565
1566 IDispatch_Release(pDispatch);
1567 IWidget_Release(pWidget);
1568
1569 trace("calling end_host_object\n");
1570 end_host_object(tid, thread);
1571 }
1572
1573 static void test_DispCallFunc(void)
1574 {
1575 static const WCHAR szEmpty[] = { 0 };
1576 VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1577 VARIANTARG vararg[4];
1578 VARIANTARG varref;
1579 VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1580 VARIANTARG varresult;
1581 HRESULT hr;
1582 IWidget *pWidget = Widget_Create();
1583 V_VT(&vararg[0]) = VT_R8;
1584 V_R8(&vararg[0]) = 3.141;
1585 V_VT(&vararg[1]) = VT_BSTR;
1586 V_BSTRREF(&vararg[1]) = CoTaskMemAlloc(sizeof(BSTR));
1587 V_VT(&vararg[2]) = VT_BSTR;
1588 V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1589 V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1590 V_VARIANTREF(&vararg[3]) = &varref;
1591 V_VT(&varref) = VT_ERROR;
1592 V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1593 VariantInit(&varresult);
1594 hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1595 ok_ole_success(hr, DispCallFunc);
1596 VariantClear(&varresult);
1597 SysFreeString(*V_BSTRREF(&vararg[1]));
1598 CoTaskMemFree(V_BSTRREF(&vararg[1]));
1599 VariantClear(&vararg[2]);
1600 IWidget_Release(pWidget);
1601 }
1602
1603 static void test_StaticWidget(void)
1604 {
1605 ITypeInfo *type_info;
1606 DISPPARAMS dispparams;
1607 VARIANTARG vararg[4];
1608 EXCEPINFO excepinfo;
1609 VARIANT varresult;
1610 HRESULT hr;
1611
1612 type_info = get_type_info(&IID_IStaticWidget);
1613
1614 /* call TestDual */
1615 dispparams.cNamedArgs = 0;
1616 dispparams.cArgs = 1;
1617 dispparams.rgdispidNamedArgs = NULL;
1618 dispparams.rgvarg = vararg;
1619 V_VT(vararg) = VT_DISPATCH;
1620 V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1621 VariantInit(&varresult);
1622 hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
1623 &dispparams, &varresult, &excepinfo, NULL);
1624 ok_ole_success(hr, IDispatch_Invoke);
1625 ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1626 VariantClear(&varresult);
1627
1628 ITypeInfo_Release(type_info);
1629 }
1630
1631 static void test_libattr(void)
1632 {
1633 ITypeLib *pTypeLib;
1634 HRESULT hr;
1635 TLIBATTR *pattr;
1636
1637 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
1638 ok_ole_success(hr, LoadRegTypeLib);
1639 if (FAILED(hr))
1640 return;
1641
1642 hr = ITypeLib_GetLibAttr(pTypeLib, &pattr);
1643 ok_ole_success(hr, GetLibAttr);
1644 if (SUCCEEDED(hr))
1645 {
1646 ok(pattr->lcid == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), "lcid %x\n", pattr->lcid);
1647
1648 ITypeLib_ReleaseTLibAttr(pTypeLib, pattr);
1649 }
1650
1651 ITypeLib_Release(pTypeLib);
1652 }
1653
1654 START_TEST(tmarshal)
1655 {
1656 HRESULT hr;
1657 HANDLE hOleaut32 = GetModuleHandleA("oleaut32.dll");
1658 pVarAdd = (void*)GetProcAddress(hOleaut32, "VarAdd");
1659
1660 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1661
1662 hr = register_current_module_typelib();
1663 if (FAILED(hr))
1664 {
1665 CoUninitialize();
1666 win_skip("Registration of the test typelib failed, skipping tests\n");
1667 return;
1668 }
1669
1670 test_typelibmarshal();
1671 test_DispCallFunc();
1672 test_StaticWidget();
1673 test_libattr();
1674
1675 hr = UnRegisterTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL,
1676 sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
1677 ok_ole_success(hr, UnRegisterTypeLib);
1678
1679 CoUninitialize();
1680 }
1681
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.