git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/tmarshal.c

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