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
  22 #include <windows.h>
  23 #include <ocidl.h>
  24 #include <stdio.h>
  25
  26 #include <wine/test.h>
  27
  28 #include "tmarshal.h"
  29 #include "tmarshal_dispids.h"
  30
  31 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", (unsigned long int)hr)
  32
  33 /* Debugging functions from wine/libs/wine/debug.c */
  34
  35 /* allocate some tmp string space */
  36 /* FIXME: this is not 100% thread-safe */
  37 static char *get_tmp_space( int size )
  38 {
  39     static char *list[32];
  40     static long pos;
  41     char *ret;
  42     int idx;
  43
  44     idx = ++pos % (sizeof(list)/sizeof(list[0]));
  45     if ((ret = realloc( list[idx], size ))) list[idx] = ret;
  46     return ret;
  47 }
  48
  49 /* default implementation of wine_dbgstr_wn */
  50 static const char *default_dbgstr_wn( const WCHAR *str, int n )
  51 {
  52     char *dst, *res;
  53
  54     if (!HIWORD(str))
  55     {
  56         if (!str) return "(null)";
  57         res = get_tmp_space( 6 );
  58         sprintf( res, "#%04x", LOWORD(str) );
  59         return res;
  60     }
  61     if (n == -1) n = lstrlenW(str);
  62     if (n < 0) n = 0;
  63     else if (n > 200) n = 200;
  64     dst = res = get_tmp_space( n * 5 + 7 );
  65     *dst++ = 'L';
  66     *dst++ = '"';
  67     while (n-- > 0)
  68     {
  69         WCHAR c = *str++;
  70         switch (c)
  71         {
  72         case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
  73         case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
  74         case '\t': *dst++ = '\\'; *dst++ = 't'; break;
  75         case '"':  *dst++ = '\\'; *dst++ = '"'; break;
  76         case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
  77         default:
  78             if (c >= ' ' && c <= 126)
  79                 *dst++ = (char)c;
  80             else
  81             {
  82                 *dst++ = '\\';
  83                 sprintf(dst,"%04x",c);
  84                 dst+=4;
  85             }
  86         }
  87     }
  88     *dst++ = '"';
  89     if (*str)
  90     {
  91         *dst++ = '.';
  92         *dst++ = '.';
  93         *dst++ = '.';
  94     }
  95     *dst = 0;
  96     return res;
  97 }
  98
  99 const char *wine_dbgstr_wn( const WCHAR *s, int n )
 100 {
 101     return default_dbgstr_wn(s, n);
 102 }
 103
 104 const char *wine_dbgstr_w( const WCHAR *s )
 105 {
 106     return default_dbgstr_wn( s, -1 );
 107 }
 108
 109
 110 #define RELEASEMARSHALDATA WM_USER
 111
 112 struct host_object_data
 113 {
 114     IStream *stream;
 115     IID iid;
 116     IUnknown *object;
 117     MSHLFLAGS marshal_flags;
 118     HANDLE marshal_event;
 119     IMessageFilter *filter;
 120 };
 121
 122 static DWORD CALLBACK host_object_proc(LPVOID p)
 123 {
 124     struct host_object_data *data = (struct host_object_data *)p;
 125     HRESULT hr;
 126     MSG msg;
 127
 128     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 129
 130     if (data->filter)
 131     {
 132         IMessageFilter * prev_filter = NULL;
 133         hr = CoRegisterMessageFilter(data->filter, &prev_filter);
 134         if (prev_filter) IMessageFilter_Release(prev_filter);
 135         ok_ole_success(hr, CoRegisterMessageFilter);
 136     }
 137
 138     hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
 139     ok_ole_success(hr, CoMarshalInterface);
 140
 141     /* force the message queue to be created before signaling parent thread */
 142     PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 143
 144     SetEvent(data->marshal_event);
 145
 146     while (GetMessage(&msg, NULL, 0, 0))
 147     {
 148         if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
 149         {
 150             trace("releasing marshal data\n");
 151             CoReleaseMarshalData(data->stream);
 152             SetEvent((HANDLE)msg.lParam);
 153         }
 154         else
 155             DispatchMessage(&msg);
 156     }
 157
 158     HeapFree(GetProcessHeap(), 0, data);
 159
 160     CoUninitialize();
 161
 162     return hr;
 163 }
 164
 165 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
 166 {
 167     DWORD tid = 0;
 168     HANDLE marshal_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 169     struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 170
 171     data->stream = stream;
 172     data->iid = *riid;
 173     data->object = object;
 174     data->marshal_flags = marshal_flags;
 175     data->marshal_event = marshal_event;
 176     data->filter = filter;
 177
 178     *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 179
 180     /* wait for marshaling to complete before returning */
 181     WaitForSingleObject(marshal_event, INFINITE);
 182     CloseHandle(marshal_event);
 183
 184     return tid;
 185 }
 186
 187 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
 188 {
 189     return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
 190 }
 191
 192 #if 0 /* not used */
 193 /* asks thread to release the marshal data because it has to be done by the
 194  * same thread that marshaled the interface in the first place. */
 195 static void release_host_object(DWORD tid)
 196 {
 197     HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
 198     PostThreadMessage(tid, RELEASEMARSHALDATA, 0, (LPARAM)event);
 199     WaitForSingleObject(event, INFINITE);
 200     CloseHandle(event);
 201 }
 202 #endif
 203
 204 static void end_host_object(DWORD tid, HANDLE thread)
 205 {
 206     BOOL ret = PostThreadMessage(tid, WM_QUIT, 0, 0);
 207     ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
 208     /* be careful of races - don't return until hosting thread has terminated */
 209     WaitForSingleObject(thread, INFINITE);
 210     CloseHandle(thread);
 211 }
 212
 213 typedef struct Widget
 214 {
 215     const IWidgetVtbl *lpVtbl;
 216     LONG refs;
 217     IUnknown *pDispatchUnknown;
 218 } Widget;
 219
 220 HRESULT WINAPI Widget_QueryInterface(
 221     IWidget *iface,
 222     /* [in] */ REFIID riid,
 223     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 224 {
 225     if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 226     {
 227         IWidget_AddRef(iface);
 228         *ppvObject = iface;
 229         return S_OK;
 230     }
 231     else
 232     {
 233         *ppvObject = NULL;
 234         return E_NOINTERFACE;
 235     }
 236 }
 237
 238 ULONG WINAPI Widget_AddRef(
 239     IWidget *iface)
 240 {
 241     Widget *This = (Widget *)iface;
 242
 243     return InterlockedIncrement(&This->refs);
 244 }
 245
 246 ULONG WINAPI Widget_Release(
 247     IWidget *iface)
 248 {
 249     Widget *This = (Widget *)iface;
 250     ULONG refs = InterlockedDecrement(&This->refs);
 251     if (!refs)
 252     {
 253         IUnknown_Release(This->pDispatchUnknown);
 254         memset(This, 0xcc, sizeof(*This));
 255         HeapFree(GetProcessHeap(), 0, This);
 256         trace("Widget destroyed!\n");
 257     }
 258
 259     return refs;
 260 }
 261
 262 HRESULT WINAPI Widget_GetTypeInfoCount(
 263     IWidget *iface,
 264     /* [out] */ UINT __RPC_FAR *pctinfo)
 265 {
 266     Widget *This = (Widget *)iface;
 267     IDispatch *pDispatch;
 268     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 269     if (SUCCEEDED(hr))
 270     {
 271         hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
 272         IDispatch_Release(pDispatch);
 273     }
 274     return hr;
 275 }
 276
 277 HRESULT WINAPI Widget_GetTypeInfo(
 278     IWidget __RPC_FAR * iface,
 279     /* [in] */ UINT iTInfo,
 280     /* [in] */ LCID lcid,
 281     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
 282 {
 283     Widget *This = (Widget *)iface;
 284     IDispatch *pDispatch;
 285     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 286     if (SUCCEEDED(hr))
 287     {
 288         hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
 289         IDispatch_Release(pDispatch);
 290     }
 291     return hr;
 292 }
 293
 294 HRESULT WINAPI Widget_GetIDsOfNames(
 295     IWidget __RPC_FAR * iface,
 296     /* [in] */ REFIID riid,
 297     /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
 298     /* [in] */ UINT cNames,
 299     /* [in] */ LCID lcid,
 300     /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
 301 {
 302     Widget *This = (Widget *)iface;
 303     IDispatch *pDispatch;
 304     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 305     if (SUCCEEDED(hr))
 306     {
 307         hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
 308         IDispatch_Release(pDispatch);
 309     }
 310     return hr;
 311 }
 312
 313 HRESULT WINAPI Widget_Invoke(
 314     IWidget __RPC_FAR * iface,
 315     /* [in] */ DISPID dispIdMember,
 316     /* [in] */ REFIID riid,
 317     /* [in] */ LCID lcid,
 318     /* [in] */ WORD wFlags,
 319     /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
 320     /* [out] */ VARIANT __RPC_FAR *pVarResult,
 321     /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
 322     /* [out] */ UINT __RPC_FAR *puArgErr)
 323 {
 324     Widget *This = (Widget *)iface;
 325     IDispatch *pDispatch;
 326     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 327     if (SUCCEEDED(hr))
 328     {
 329         hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 330         IDispatch_Release(pDispatch);
 331     }
 332     return hr;
 333 }
 334
 335 HRESULT WINAPI Widget_put_Name(
 336     IWidget __RPC_FAR * iface,
 337     /* [in] */ BSTR name)
 338 {
 339     trace("put_Name(%s)\n", wine_dbgstr_w(name));
 340     return S_OK;
 341 }
 342
 343 HRESULT WINAPI Widget_get_Name(
 344     IWidget __RPC_FAR * iface,
 345     /* [out] */ BSTR __RPC_FAR *name)
 346 {
 347     static const WCHAR szCat[] = { 'C','a','t',0 };
 348     trace("get_Name()\n");
 349     *name = SysAllocString(szCat);
 350     return S_OK;
 351 }
 352
 353 HRESULT WINAPI Widget_DoSomething(
 354     IWidget __RPC_FAR * iface,
 355     /* [in] */ double number,
 356     /* [out] */ BSTR *str1,
 357     /* [defaultvalue][in] */ BSTR str2,
 358     /* [optional][in] */ VARIANT __RPC_FAR *opt)
 359 {
 360     static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
 361     trace("DoSomething()\n");
 362
 363     ok(number == 3.141, "number(%f) != 3.141\n", number);
 364     ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
 365     ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
 366     ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
 367     *str1 = SysAllocString(szString);
 368
 369     return S_FALSE;
 370 }
 371
 372 HRESULT WINAPI Widget_get_State(
 373     IWidget __RPC_FAR * iface,
 374     /* [retval][out] */ STATE __RPC_FAR *state)
 375 {
 376     trace("get_State() = STATE_WIDGETIFIED\n");
 377     *state = STATE_WIDGETIFIED;
 378     return S_OK;
 379 }
 380
 381 HRESULT WINAPI Widget_put_State(
 382     IWidget __RPC_FAR * iface,
 383     /* [in] */ STATE state)
 384 {
 385     trace("put_State(%d)\n", state);
 386     return S_OK;
 387 }
 388
 389 HRESULT WINAPI Widget_Map(
 390     IWidget * iface,
 391     BSTR bstrId,
 392     BSTR *sValue)
 393 {
 394     trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
 395     *sValue = SysAllocString(bstrId);
 396     return S_OK;
 397 }
 398
 399 HRESULT WINAPI Widget_SetOleColor(
 400     IWidget * iface,
 401     OLE_COLOR val)
 402 {
 403     trace("SetOleColor(0x%x)\n", val);
 404     return S_OK;
 405 }
 406
 407 HRESULT WINAPI Widget_GetOleColor(
 408     IWidget * iface,
 409     OLE_COLOR *pVal)
 410 {
 411     trace("GetOleColor() = 0x8000000f\n");
 412     *pVal = 0x8000000f;
 413     return S_FALSE;
 414 }
 415
 416 HRESULT WINAPI Widget_Clone(
 417     IWidget *iface,
 418     IWidget **ppVal)
 419 {
 420     trace("Clone()\n");
 421     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 422 }
 423
 424 HRESULT WINAPI Widget_CloneDispatch(
 425     IWidget *iface,
 426     IDispatch **ppVal)
 427 {
 428     trace("CloneDispatch()\n");
 429     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 430 }
 431
 432 HRESULT WINAPI Widget_CloneCoclass(
 433     IWidget *iface,
 434     ApplicationObject2 **ppVal)
 435 {
 436     trace("CloneCoclass()\n");
 437     return S_OK;
 438 }
 439
 440 HRESULT WINAPI Widget_Value(
 441     IWidget __RPC_FAR * iface,
 442     VARIANT *value,
 443     VARIANT *retval)
 444 {
 445     trace("Value(%p, %p)\n", value, retval);
 446     ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
 447     ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
 448     V_VT(retval) = VT_I2;
 449     V_I2(retval) = 1234;
 450     return S_OK;
 451 }
 452
 453 HRESULT WINAPI Widget_Array(
 454     IWidget * iface,
 455     SAFEARRAY * values)
 456 {
 457     trace("Array(%p)\n", values);
 458     return S_OK;
 459 }
 460
 461 HRESULT WINAPI Widget_VariantArrayPtr(
 462     IWidget * iface,
 463     SAFEARRAY ** values)
 464 {
 465     trace("VariantArrayPtr(%p)\n", values);
 466     return S_OK;
 467 }
 468
 469 void WINAPI Widget_Variant(
 470     IWidget __RPC_FAR * iface,
 471     VARIANT var)
 472 {
 473     trace("Variant()\n");
 474     ok(V_VT(&var) == VT_CY, "V_VT(&var) was %d\n", V_VT(&var));
 475     ok(S(V_CY(&var)).Hi == 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var)).Hi);
 476     ok(S(V_CY(&var)).Lo == 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var)).Lo);
 477 }
 478
 479 HRESULT WINAPI Widget_Error(
 480     IWidget __RPC_FAR * iface)
 481 {
 482     trace("Error()\n");
 483     return E_NOTIMPL;
 484 }
 485
 486 static const struct IWidgetVtbl Widget_VTable =
 487 {
 488     Widget_QueryInterface,
 489     Widget_AddRef,
 490     Widget_Release,
 491     Widget_GetTypeInfoCount,
 492     Widget_GetTypeInfo,
 493     Widget_GetIDsOfNames,
 494     Widget_Invoke,
 495     Widget_put_Name,
 496     Widget_get_Name,
 497     Widget_DoSomething,
 498     Widget_get_State,
 499     Widget_put_State,
 500     Widget_Map,
 501     Widget_SetOleColor,
 502     Widget_GetOleColor,
 503     Widget_Clone,
 504     Widget_CloneDispatch,
 505     Widget_CloneCoclass,
 506     Widget_Value,
 507     Widget_Array,
 508     Widget_VariantArrayPtr,
 509     Widget_Variant,
 510     Widget_Error
 511 };
 512
 513
 514 typedef struct KindaEnum
 515 {
 516     const IKindaEnumWidgetVtbl *lpVtbl;
 517     LONG refs;
 518 } KindaEnum;
 519
 520 static HRESULT register_current_module_typelib(void)
 521 {
 522     WCHAR path[MAX_PATH];
 523     HRESULT hr;
 524     ITypeLib *typelib;
 525
 526     GetModuleFileNameW(NULL, path, MAX_PATH);
 527
 528     hr = LoadTypeLib(path, &typelib);
 529     if (SUCCEEDED(hr))
 530     {
 531         hr = RegisterTypeLib(typelib, path, NULL);
 532         ITypeLib_Release(typelib);
 533     }
 534     return hr;
 535 }
 536
 537 static IWidget *Widget_Create(void)
 538 {
 539     Widget *This = (Widget *)HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 540     HRESULT hr;
 541     ITypeLib *pTypeLib;
 542
 543     This->lpVtbl = &Widget_VTable;
 544     This->refs = 1;
 545
 546     hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
 547     ok_ole_success(hr, LoadRegTypeLib);
 548     if (SUCCEEDED(hr))
 549     {
 550         ITypeInfo *pTypeInfo;
 551         hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IWidget, &pTypeInfo);
 552         ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 553         if (SUCCEEDED(hr))
 554         {
 555             This->pDispatchUnknown = NULL;
 556             hr = CreateStdDispatch((IUnknown *)&This->lpVtbl, This, pTypeInfo, &This->pDispatchUnknown);
 557             ok_ole_success(hr, CreateStdDispatch);
 558             ITypeInfo_Release(pTypeInfo);
 559         }
 560     }
 561
 562     if (SUCCEEDED(hr))
 563         return (IWidget *)&This->lpVtbl;
 564     else
 565     {
 566         HeapFree(GetProcessHeap(), 0, This);
 567         return NULL;
 568     }
 569 }
 570
 571 HRESULT WINAPI KindaEnum_QueryInterface(
 572     IKindaEnumWidget *iface,
 573     /* [in] */ REFIID riid,
 574     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 575 {
 576     if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
 577     {
 578         IKindaEnumWidget_AddRef(iface);
 579         *ppvObject = iface;
 580         return S_OK;
 581     }
 582     else
 583     {
 584         *ppvObject = NULL;
 585         return E_NOINTERFACE;
 586     }
 587 }
 588
 589 ULONG WINAPI KindaEnum_AddRef(
 590     IKindaEnumWidget *iface)
 591 {
 592     KindaEnum *This = (KindaEnum *)iface;
 593
 594     return InterlockedIncrement(&This->refs);
 595 }
 596
 597 ULONG WINAPI KindaEnum_Release(
 598     IKindaEnumWidget *iface)
 599 {
 600     KindaEnum *This = (KindaEnum *)iface;
 601     ULONG refs = InterlockedDecrement(&This->refs);
 602     if (!refs)
 603     {
 604         memset(This, 0xcc, sizeof(*This));
 605         HeapFree(GetProcessHeap(), 0, This);
 606         trace("KindaEnumWidget destroyed!\n");
 607     }
 608
 609     return refs;
 610 }
 611
 612 HRESULT WINAPI KindaEnum_Next(
 613     IKindaEnumWidget *iface,
 614     /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
 615 {
 616     *widget = Widget_Create();
 617     if (*widget)
 618         return S_OK;
 619     else
 620         return E_OUTOFMEMORY;
 621 }
 622
 623 HRESULT WINAPI KindaEnum_Count(
 624     IKindaEnumWidget *iface,
 625     /* [out] */ unsigned long __RPC_FAR *count)
 626 {
 627     return E_NOTIMPL;
 628 }
 629
 630 HRESULT WINAPI KindaEnum_Reset(
 631     IKindaEnumWidget *iface)
 632 {
 633     return E_NOTIMPL;
 634 }
 635
 636 HRESULT WINAPI KindaEnum_Clone(
 637     IKindaEnumWidget *iface,
 638     /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
 639 {
 640     return E_NOTIMPL;
 641 }
 642
 643 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
 644 {
 645     KindaEnum_QueryInterface,
 646     KindaEnum_AddRef,
 647     KindaEnum_Release,
 648     KindaEnum_Next,
 649     KindaEnum_Count,
 650     KindaEnum_Reset,
 651     KindaEnum_Clone
 652 };
 653
 654 static IKindaEnumWidget *KindaEnumWidget_Create(void)
 655 {
 656     KindaEnum *This;
 657
 658     This = (KindaEnum *)HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 659     if (!This) return NULL;
 660     This->lpVtbl = &KindaEnumWidget_VTable;
 661     This->refs = 1;
 662     return (IKindaEnumWidget *)This;
 663 }
 664
 665 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
 666 {
 667     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
 668     {
 669         *(INonOleAutomation **)ppv = iface;
 670         return S_OK;
 671     }
 672     *ppv = NULL;
 673     return E_NOINTERFACE;
 674 }
 675
 676 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
 677 {
 678     return 2;
 679 }
 680
 681 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
 682 {
 683     return 1;
 684 }
 685
 686 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
 687 {
 688     static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
 689     return SysAllocString(wszTestString);
 690 }
 691
 692 static INonOleAutomationVtbl NonOleAutomation_VTable =
 693 {
 694     NonOleAutomation_QueryInterface,
 695     NonOleAutomation_AddRef,
 696     NonOleAutomation_Release,
 697     NonOleAutomation_BstrRet,
 698 };
 699
 700 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
 701
 702 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
 703 {
 704     ITypeLib *pTypeLib;
 705     HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
 706     ok_ole_success(hr, LoadRegTypeLib);
 707     if (SUCCEEDED(hr))
 708     {
 709         ITypeInfo *pTypeInfo;
 710         hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
 711         ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 712         return pTypeInfo;
 713     }
 714     return NULL;
 715 }
 716
 717 static void test_typelibmarshal(void)
 718 {
 719     static const WCHAR szCat[] = { 'C','a','t',0 };
 720     static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
 721     static WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
 722     HRESULT hr;
 723     IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
 724     IWidget *pWidget;
 725     IStream *pStream;
 726     IDispatch *pDispatch;
 727     static const LARGE_INTEGER ullZero;
 728     EXCEPINFO excepinfo;
 729     VARIANT varresult;
 730     DISPID dispidNamed = DISPID_PROPERTYPUT;
 731     DISPPARAMS dispparams;
 732     VARIANTARG vararg[4];
 733     STATE the_state;
 734     HANDLE thread;
 735     DWORD tid;
 736     BSTR bstr;
 737     ITypeInfo *pTypeInfo;
 738
 739     ok(pKEW != NULL, "Widget creation failed\n");
 740
 741     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 742     ok_ole_success(hr, CreateStreamOnHGlobal);
 743     tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
 744
 745     IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
 746     hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
 747     ok_ole_success(hr, CoUnmarshalInterface);
 748     IStream_Release(pStream);
 749
 750     hr = IKindaEnumWidget_Next(pKEW, &pWidget);
 751     ok_ole_success(hr, IKindaEnumWidget_Next);
 752
 753     IKindaEnumWidget_Release(pKEW);
 754
 755     hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
 756
 757     /* call put_Name */
 758     VariantInit(&vararg[0]);
 759     dispparams.cNamedArgs = 1;
 760     dispparams.rgdispidNamedArgs = &dispidNamed;
 761     dispparams.cArgs = 1;
 762     dispparams.rgvarg = vararg;
 763     VariantInit(&varresult);
 764     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 765     ok_ole_success(hr, IDispatch_Invoke);
 766     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 767         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 768         excepinfo.wCode, excepinfo.scode);
 769     VariantClear(&varresult);
 770
 771     /* call put_Name (direct) */
 772     bstr = SysAllocString(szSuperman);
 773     hr = IWidget_put_Name(pWidget, bstr);
 774     ok_ole_success(hr, IWidget_put_Name);
 775     SysFreeString(bstr);
 776
 777     /* call get_Name */
 778     dispparams.cNamedArgs = 0;
 779     dispparams.rgdispidNamedArgs = NULL;
 780     dispparams.cArgs = 0;
 781     dispparams.rgvarg = NULL;
 782     VariantInit(&varresult);
 783     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 784     ok_ole_success(hr, IDispatch_Invoke);
 785     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 786         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 787         excepinfo.wCode, excepinfo.scode);
 788     trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
 789     VariantClear(&varresult);
 790
 791     /* call get_Name (direct) */
 792     bstr = NULL;
 793     hr = IWidget_get_Name(pWidget, &bstr);
 794     ok_ole_success(hr, IWidget_get_Name);
 795     ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
 796     SysFreeString(bstr);
 797
 798     /* call DoSomething */
 799     VariantInit(&vararg[0]);
 800     VariantInit(&vararg[1]);
 801     V_VT(&vararg[1]) = VT_R8;
 802     V_R8(&vararg[1]) = 3.141;
 803     dispparams.cNamedArgs = 0;
 804     dispparams.cArgs = 2;
 805     dispparams.rgdispidNamedArgs = NULL;
 806     dispparams.rgvarg = vararg;
 807     VariantInit(&varresult);
 808     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 809     ok_ole_success(hr, IDispatch_Invoke);
 810     ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
 811     VariantClear(&varresult);
 812
 813     /* call get_State */
 814     dispparams.cNamedArgs = 0;
 815     dispparams.cArgs = 0;
 816     dispparams.rgdispidNamedArgs = NULL;
 817     dispparams.rgvarg = NULL;
 818     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 819     ok_ole_success(hr, IDispatch_Invoke);
 820     ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
 821
 822     /* call get_State (direct) */
 823     hr = IWidget_get_State(pWidget, &the_state);
 824     ok_ole_success(hr, IWidget_get_state);
 825     ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
 826
 827     /* call put_State */
 828     the_state = STATE_WIDGETIFIED;
 829     VariantInit(&vararg[0]);
 830     V_VT(&vararg[0]) = VT_BYREF|VT_I4;
 831     V_I4REF(&vararg[0]) = (int *)&the_state;
 832     dispparams.cNamedArgs = 1;
 833     dispparams.cArgs = 1;
 834     dispparams.rgdispidNamedArgs = &dispidNamed;
 835     dispparams.rgvarg = vararg;
 836     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 837     ok_ole_success(hr, IDispatch_Invoke);
 838
 839     /* call Map */
 840     bstr = SysAllocString(szTestTest);
 841     VariantInit(&vararg[0]);
 842     V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
 843     V_BSTRREF(&vararg[0]) = &bstr;
 844     dispparams.cNamedArgs = 0;
 845     dispparams.cArgs = 1;
 846     dispparams.rgdispidNamedArgs = NULL;
 847     dispparams.rgvarg = vararg;
 848     VariantInit(&varresult);
 849     hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 850     ok_ole_success(hr, IDispatch_Invoke);
 851     ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
 852     ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
 853     VariantClear(&varresult);
 854
 855     /* call SetOleColor with large negative VT_I4 param */
 856     VariantInit(&vararg[0]);
 857     V_VT(&vararg[0]) = VT_I4;
 858     V_I4(&vararg[0]) = 0x80000005;
 859     dispparams.cNamedArgs = 0;
 860     dispparams.cArgs = 1;
 861     dispparams.rgdispidNamedArgs = NULL;
 862     dispparams.rgvarg = vararg;
 863     hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
 864     ok_ole_success(hr, IDispatch_Invoke);
 865
 866     /* call GetOleColor */
 867     dispparams.cNamedArgs = 0;
 868     dispparams.cArgs = 0;
 869     dispparams.rgdispidNamedArgs = NULL;
 870     dispparams.rgvarg = NULL;
 871     VariantInit(&varresult);
 872     hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 873     ok_ole_success(hr, IDispatch_Invoke);
 874     VariantClear(&varresult);
 875
 876     /* call Clone */
 877     dispparams.cNamedArgs = 0;
 878     dispparams.cArgs = 0;
 879     dispparams.rgdispidNamedArgs = NULL;
 880     dispparams.rgvarg = NULL;
 881     VariantInit(&varresult);
 882     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 883     ok_ole_success(hr, IDispatch_Invoke);
 884     VariantClear(&varresult);
 885
 886     /* call CloneDispatch with automatic value getting */
 887     V_VT(&vararg[0]) = VT_I2;
 888     V_I2(&vararg[0]) = 1;
 889     dispparams.cNamedArgs = 0;
 890     dispparams.rgdispidNamedArgs = NULL;
 891     dispparams.cArgs = 1;
 892     dispparams.rgvarg = vararg;
 893     VariantInit(&varresult);
 894     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 895     ok_ole_success(hr, IDispatch_Invoke);
 896
 897     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 898         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 899         excepinfo.wCode, excepinfo.scode);
 900
 901     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
 902     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
 903     VariantClear(&varresult);
 904
 905     /* call CloneCoclass */
 906     dispparams.cNamedArgs = 0;
 907     dispparams.cArgs = 0;
 908     dispparams.rgdispidNamedArgs = NULL;
 909     dispparams.rgvarg = NULL;
 910     VariantInit(&varresult);
 911     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 912     ok_ole_success(hr, IDispatch_Invoke);
 913
 914     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 915        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 916        excepinfo.wCode, excepinfo.scode);
 917
 918     ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
 919     ok(!V_DISPATCH(&varresult), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult));
 920     VariantClear(&varresult);
 921
 922     /* call Value with a VT_VARIANT|VT_BYREF type */
 923     V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
 924     V_VARIANTREF(&vararg[0]) = &vararg[1];
 925     V_VT(&vararg[1]) = VT_I2;
 926     V_I2(&vararg[1]) = 1;
 927     dispparams.cNamedArgs = 0;
 928     dispparams.rgdispidNamedArgs = NULL;
 929     dispparams.cArgs = 1;
 930     dispparams.rgvarg = vararg;
 931     VariantInit(&varresult);
 932     hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 933     ok_ole_success(hr, IDispatch_Invoke);
 934
 935     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 936         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 937         excepinfo.wCode, excepinfo.scode);
 938
 939     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
 940     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
 941     VariantClear(&varresult);
 942
 943     /* call Variant - exercises variant copying in ITypeInfo::Invoke and
 944      * handling of void return types */
 945     /* use a big type to ensure that the variant was properly copied into the
 946      * destination function's args */
 947     V_VT(&vararg[0]) = VT_CY;
 948     S(V_CY(&vararg[0])).Hi = 0xdababe;
 949     S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
 950     dispparams.cNamedArgs = 0;
 951     dispparams.cArgs = 1;
 952     dispparams.rgdispidNamedArgs = NULL;
 953     dispparams.rgvarg = vararg;
 954     VariantInit(&varresult);
 955     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 956     ok_ole_success(hr, IDispatch_Invoke);
 957     VariantClear(&varresult);
 958
 959     /* call Error */
 960     dispparams.cNamedArgs = 0;
 961     dispparams.cArgs = 0;
 962     dispparams.rgdispidNamedArgs = NULL;
 963     dispparams.rgvarg = NULL;
 964     VariantInit(&varresult);
 965     hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
 966     ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
 967     ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
 968         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 969         excepinfo.wCode, excepinfo.scode);
 970     VariantClear(&varresult);
 971
 972     /* call BstrRet */
 973     pTypeInfo = NonOleAutomation_GetTypeInfo();
 974     dispparams.cNamedArgs = 0;
 975     dispparams.cArgs = 0;
 976     dispparams.rgdispidNamedArgs = NULL;
 977     dispparams.rgvarg = NULL;
 978     VariantInit(&varresult);
 979     hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 980     ok_ole_success(hr, ITypeInfo_Invoke);
 981     ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
 982     ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
 983
 984     VariantClear(&varresult);
 985     ITypeInfo_Release(pTypeInfo);
 986
 987     /* tests call put_Name without named arg */
 988     VariantInit(&vararg[0]);
 989     dispparams.cNamedArgs = 0;
 990     dispparams.rgdispidNamedArgs = NULL;
 991     dispparams.cArgs = 1;
 992     dispparams.rgvarg = vararg;
 993     VariantInit(&varresult);
 994     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 995     ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
 996     VariantClear(&varresult);
 997
 998     /* tests param type that cannot be coerced */
 999     VariantInit(&vararg[0]);
1000     V_VT(&vararg[0]) = VT_UNKNOWN;
1001     V_UNKNOWN(&vararg[0]) = NULL;
1002     dispparams.cNamedArgs = 1;
1003     dispparams.rgdispidNamedArgs = &dispidNamed;
1004     dispparams.cArgs = 1;
1005     dispparams.rgvarg = vararg;
1006     VariantInit(&varresult);
1007 #if 0 /* NULL unknown not currently marshaled correctly */
1008     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1009     ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1010 #endif
1011     VariantClear(&varresult);
1012
1013     /* tests bad param type */
1014     VariantInit(&vararg[0]);
1015     V_VT(&vararg[0]) = VT_CLSID;
1016     V_BYREF(&vararg[0]) = NULL;
1017     dispparams.cNamedArgs = 1;
1018     dispparams.rgdispidNamedArgs = &dispidNamed;
1019     dispparams.cArgs = 1;
1020     dispparams.rgvarg = vararg;
1021     VariantInit(&varresult);
1022     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1023     ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1024     VariantClear(&varresult);
1025
1026     /* tests too small param count */
1027     dispparams.cNamedArgs = 0;
1028     dispparams.rgdispidNamedArgs = NULL;
1029     dispparams.cArgs = 0;
1030     dispparams.rgvarg = NULL;
1031     VariantInit(&varresult);
1032     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1033     ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1034     VariantClear(&varresult);
1035
1036     /* tests propget function with large param count */
1037     VariantInit(&vararg[0]);
1038     V_VT(&vararg[0]) = VT_BSTR;
1039     V_BSTR(&vararg[0]) = NULL;
1040     V_VT(&vararg[1]) = VT_I4;
1041     V_I4(&vararg[1]) = 1;
1042     dispparams.cNamedArgs = 0;
1043     dispparams.cArgs = 2;
1044     dispparams.rgdispidNamedArgs = NULL;
1045     dispparams.rgvarg = vararg;
1046     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1047     ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1048
1049     IDispatch_Release(pDispatch);
1050     IWidget_Release(pWidget);
1051
1052     trace("calling end_host_object\n");
1053     end_host_object(tid, thread);
1054 }
1055
1056 static void test_DispCallFunc(void)
1057 {
1058     static const WCHAR szEmpty[] = { 0 };
1059     VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1060     VARIANTARG vararg[4];
1061     VARIANTARG varref;
1062     VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1063     VARIANTARG varresult;
1064     HRESULT hr;
1065     IWidget *pWidget = Widget_Create();
1066     V_VT(&vararg[0]) = VT_R8;
1067     V_R8(&vararg[0]) = 3.141;
1068     V_VT(&vararg[1]) = VT_BSTR;
1069     V_BSTR(&vararg[1]) = SysAllocString(szEmpty);
1070     V_VT(&vararg[2]) = VT_BSTR;
1071     V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1072     V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1073     V_VARIANTREF(&vararg[3]) = &varref;
1074     V_VT(&varref) = VT_ERROR;
1075     V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1076     VariantInit(&varresult);
1077     hr = DispCallFunc(pWidget, 36, CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1078     ok_ole_success(hr, DispCallFunc);
1079     VariantClear(&varresult);
1080 }
1081
1082 START_TEST(tmarshal)
1083 {
1084     HRESULT hr;
1085
1086     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1087
1088     hr = register_current_module_typelib();
1089     ok_ole_success(hr, register_current_module_typelib);
1090
1091     test_typelibmarshal();
1092     test_DispCallFunc();
1093
1094     CoUninitialize();
1095 }