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 void WINAPI Widget_VarArg(
 480     IWidget * iface,
 481     int numexpect,
 482     SAFEARRAY * values)
 483 {
 484     LONG lbound, ubound, i;
 485     VARIANT * data;
 486     HRESULT hr;
 487
 488     trace("VarArg(%p)\n", values);
 489
 490     hr = SafeArrayGetLBound(values, 1, &lbound);
 491     ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
 492     ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
 493
 494     hr = SafeArrayGetUBound(values, 1, &ubound);
 495     ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
 496     ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
 497
 498     hr = SafeArrayAccessData(values, (LPVOID)&data);
 499     ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 500
 501     for (i=0; i<=ubound-lbound; i++)
 502     {
 503         ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
 504         ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
 505     }
 506
 507     hr = SafeArrayUnaccessData(values);
 508     ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
 509 }
 510
 511 HRESULT WINAPI Widget_Error(
 512     IWidget __RPC_FAR * iface)
 513 {
 514     trace("Error()\n");
 515     return E_NOTIMPL;
 516 }
 517
 518 static const struct IWidgetVtbl Widget_VTable =
 519 {
 520     Widget_QueryInterface,
 521     Widget_AddRef,
 522     Widget_Release,
 523     Widget_GetTypeInfoCount,
 524     Widget_GetTypeInfo,
 525     Widget_GetIDsOfNames,
 526     Widget_Invoke,
 527     Widget_put_Name,
 528     Widget_get_Name,
 529     Widget_DoSomething,
 530     Widget_get_State,
 531     Widget_put_State,
 532     Widget_Map,
 533     Widget_SetOleColor,
 534     Widget_GetOleColor,
 535     Widget_Clone,
 536     Widget_CloneDispatch,
 537     Widget_CloneCoclass,
 538     Widget_Value,
 539     Widget_Array,
 540     Widget_VariantArrayPtr,
 541     Widget_Variant,
 542     Widget_VarArg,
 543     Widget_Error
 544 };
 545
 546
 547 typedef struct KindaEnum
 548 {
 549     const IKindaEnumWidgetVtbl *lpVtbl;
 550     LONG refs;
 551 } KindaEnum;
 552
 553 static HRESULT register_current_module_typelib(void)
 554 {
 555     WCHAR path[MAX_PATH];
 556     HRESULT hr;
 557     ITypeLib *typelib;
 558
 559     GetModuleFileNameW(NULL, path, MAX_PATH);
 560
 561     hr = LoadTypeLib(path, &typelib);
 562     if (SUCCEEDED(hr))
 563     {
 564         hr = RegisterTypeLib(typelib, path, NULL);
 565         ITypeLib_Release(typelib);
 566     }
 567     return hr;
 568 }
 569
 570 static IWidget *Widget_Create(void)
 571 {
 572     Widget *This = (Widget *)HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 573     HRESULT hr;
 574     ITypeLib *pTypeLib;
 575
 576     This->lpVtbl = &Widget_VTable;
 577     This->refs = 1;
 578
 579     hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
 580     ok_ole_success(hr, LoadRegTypeLib);
 581     if (SUCCEEDED(hr))
 582     {
 583         ITypeInfo *pTypeInfo;
 584         hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IWidget, &pTypeInfo);
 585         ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 586         if (SUCCEEDED(hr))
 587         {
 588             This->pDispatchUnknown = NULL;
 589             hr = CreateStdDispatch((IUnknown *)&This->lpVtbl, This, pTypeInfo, &This->pDispatchUnknown);
 590             ok_ole_success(hr, CreateStdDispatch);
 591             ITypeInfo_Release(pTypeInfo);
 592         }
 593     }
 594
 595     if (SUCCEEDED(hr))
 596         return (IWidget *)&This->lpVtbl;
 597     else
 598     {
 599         HeapFree(GetProcessHeap(), 0, This);
 600         return NULL;
 601     }
 602 }
 603
 604 HRESULT WINAPI KindaEnum_QueryInterface(
 605     IKindaEnumWidget *iface,
 606     /* [in] */ REFIID riid,
 607     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 608 {
 609     if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
 610     {
 611         IKindaEnumWidget_AddRef(iface);
 612         *ppvObject = iface;
 613         return S_OK;
 614     }
 615     else
 616     {
 617         *ppvObject = NULL;
 618         return E_NOINTERFACE;
 619     }
 620 }
 621
 622 ULONG WINAPI KindaEnum_AddRef(
 623     IKindaEnumWidget *iface)
 624 {
 625     KindaEnum *This = (KindaEnum *)iface;
 626
 627     return InterlockedIncrement(&This->refs);
 628 }
 629
 630 ULONG WINAPI KindaEnum_Release(
 631     IKindaEnumWidget *iface)
 632 {
 633     KindaEnum *This = (KindaEnum *)iface;
 634     ULONG refs = InterlockedDecrement(&This->refs);
 635     if (!refs)
 636     {
 637         memset(This, 0xcc, sizeof(*This));
 638         HeapFree(GetProcessHeap(), 0, This);
 639         trace("KindaEnumWidget destroyed!\n");
 640     }
 641
 642     return refs;
 643 }
 644
 645 HRESULT WINAPI KindaEnum_Next(
 646     IKindaEnumWidget *iface,
 647     /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
 648 {
 649     *widget = Widget_Create();
 650     if (*widget)
 651         return S_OK;
 652     else
 653         return E_OUTOFMEMORY;
 654 }
 655
 656 HRESULT WINAPI KindaEnum_Count(
 657     IKindaEnumWidget *iface,
 658     /* [out] */ unsigned long __RPC_FAR *count)
 659 {
 660     return E_NOTIMPL;
 661 }
 662
 663 HRESULT WINAPI KindaEnum_Reset(
 664     IKindaEnumWidget *iface)
 665 {
 666     return E_NOTIMPL;
 667 }
 668
 669 HRESULT WINAPI KindaEnum_Clone(
 670     IKindaEnumWidget *iface,
 671     /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
 672 {
 673     return E_NOTIMPL;
 674 }
 675
 676 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
 677 {
 678     KindaEnum_QueryInterface,
 679     KindaEnum_AddRef,
 680     KindaEnum_Release,
 681     KindaEnum_Next,
 682     KindaEnum_Count,
 683     KindaEnum_Reset,
 684     KindaEnum_Clone
 685 };
 686
 687 static IKindaEnumWidget *KindaEnumWidget_Create(void)
 688 {
 689     KindaEnum *This;
 690
 691     This = (KindaEnum *)HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 692     if (!This) return NULL;
 693     This->lpVtbl = &KindaEnumWidget_VTable;
 694     This->refs = 1;
 695     return (IKindaEnumWidget *)This;
 696 }
 697
 698 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
 699 {
 700     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
 701     {
 702         *(INonOleAutomation **)ppv = iface;
 703         return S_OK;
 704     }
 705     *ppv = NULL;
 706     return E_NOINTERFACE;
 707 }
 708
 709 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
 710 {
 711     return 2;
 712 }
 713
 714 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
 715 {
 716     return 1;
 717 }
 718
 719 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
 720 {
 721     static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
 722     return SysAllocString(wszTestString);
 723 }
 724
 725 static INonOleAutomationVtbl NonOleAutomation_VTable =
 726 {
 727     NonOleAutomation_QueryInterface,
 728     NonOleAutomation_AddRef,
 729     NonOleAutomation_Release,
 730     NonOleAutomation_BstrRet,
 731 };
 732
 733 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
 734
 735 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
 736 {
 737     ITypeLib *pTypeLib;
 738     HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &pTypeLib);
 739     ok_ole_success(hr, LoadRegTypeLib);
 740     if (SUCCEEDED(hr))
 741     {
 742         ITypeInfo *pTypeInfo;
 743         hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
 744         ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 745         return pTypeInfo;
 746     }
 747     return NULL;
 748 }
 749
 750 static void test_typelibmarshal(void)
 751 {
 752     static const WCHAR szCat[] = { 'C','a','t',0 };
 753     static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
 754     static WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
 755     HRESULT hr;
 756     IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
 757     IWidget *pWidget;
 758     IStream *pStream;
 759     IDispatch *pDispatch;
 760     static const LARGE_INTEGER ullZero;
 761     EXCEPINFO excepinfo;
 762     VARIANT varresult;
 763     DISPID dispidNamed = DISPID_PROPERTYPUT;
 764     DISPPARAMS dispparams;
 765     VARIANTARG vararg[4];
 766     STATE the_state;
 767     HANDLE thread;
 768     DWORD tid;
 769     BSTR bstr;
 770     ITypeInfo *pTypeInfo;
 771
 772     ok(pKEW != NULL, "Widget creation failed\n");
 773
 774     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 775     ok_ole_success(hr, CreateStreamOnHGlobal);
 776     tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
 777
 778     IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
 779     hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
 780     ok_ole_success(hr, CoUnmarshalInterface);
 781     IStream_Release(pStream);
 782
 783     hr = IKindaEnumWidget_Next(pKEW, &pWidget);
 784     ok_ole_success(hr, IKindaEnumWidget_Next);
 785
 786     IKindaEnumWidget_Release(pKEW);
 787
 788     hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
 789
 790     /* call put_Name */
 791     VariantInit(&vararg[0]);
 792     dispparams.cNamedArgs = 1;
 793     dispparams.rgdispidNamedArgs = &dispidNamed;
 794     dispparams.cArgs = 1;
 795     dispparams.rgvarg = vararg;
 796     VariantInit(&varresult);
 797     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 798     ok_ole_success(hr, IDispatch_Invoke);
 799     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 800         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 801         excepinfo.wCode, excepinfo.scode);
 802     VariantClear(&varresult);
 803
 804     /* call put_Name (direct) */
 805     bstr = SysAllocString(szSuperman);
 806     hr = IWidget_put_Name(pWidget, bstr);
 807     ok_ole_success(hr, IWidget_put_Name);
 808     SysFreeString(bstr);
 809
 810     /* call get_Name */
 811     dispparams.cNamedArgs = 0;
 812     dispparams.rgdispidNamedArgs = NULL;
 813     dispparams.cArgs = 0;
 814     dispparams.rgvarg = NULL;
 815     VariantInit(&varresult);
 816     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 817     ok_ole_success(hr, IDispatch_Invoke);
 818     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 819         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 820         excepinfo.wCode, excepinfo.scode);
 821     trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
 822     VariantClear(&varresult);
 823
 824     /* call get_Name (direct) */
 825     bstr = NULL;
 826     hr = IWidget_get_Name(pWidget, &bstr);
 827     ok_ole_success(hr, IWidget_get_Name);
 828     ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
 829     SysFreeString(bstr);
 830
 831     /* call DoSomething */
 832     VariantInit(&vararg[0]);
 833     VariantInit(&vararg[1]);
 834     V_VT(&vararg[1]) = VT_R8;
 835     V_R8(&vararg[1]) = 3.141;
 836     dispparams.cNamedArgs = 0;
 837     dispparams.cArgs = 2;
 838     dispparams.rgdispidNamedArgs = NULL;
 839     dispparams.rgvarg = vararg;
 840     VariantInit(&varresult);
 841     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 842     ok_ole_success(hr, IDispatch_Invoke);
 843     ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
 844     VariantClear(&varresult);
 845
 846     /* call get_State */
 847     dispparams.cNamedArgs = 0;
 848     dispparams.cArgs = 0;
 849     dispparams.rgdispidNamedArgs = NULL;
 850     dispparams.rgvarg = NULL;
 851     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 852     ok_ole_success(hr, IDispatch_Invoke);
 853     ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
 854
 855     /* call get_State (direct) */
 856     hr = IWidget_get_State(pWidget, &the_state);
 857     ok_ole_success(hr, IWidget_get_state);
 858     ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
 859
 860     /* call put_State */
 861     the_state = STATE_WIDGETIFIED;
 862     VariantInit(&vararg[0]);
 863     V_VT(&vararg[0]) = VT_BYREF|VT_I4;
 864     V_I4REF(&vararg[0]) = (int *)&the_state;
 865     dispparams.cNamedArgs = 1;
 866     dispparams.cArgs = 1;
 867     dispparams.rgdispidNamedArgs = &dispidNamed;
 868     dispparams.rgvarg = vararg;
 869     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 870     ok_ole_success(hr, IDispatch_Invoke);
 871
 872     /* call Map */
 873     bstr = SysAllocString(szTestTest);
 874     VariantInit(&vararg[0]);
 875     V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
 876     V_BSTRREF(&vararg[0]) = &bstr;
 877     dispparams.cNamedArgs = 0;
 878     dispparams.cArgs = 1;
 879     dispparams.rgdispidNamedArgs = NULL;
 880     dispparams.rgvarg = vararg;
 881     VariantInit(&varresult);
 882     hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 883     ok_ole_success(hr, IDispatch_Invoke);
 884     ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
 885     ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
 886     VariantClear(&varresult);
 887
 888     /* call SetOleColor with large negative VT_I4 param */
 889     VariantInit(&vararg[0]);
 890     V_VT(&vararg[0]) = VT_I4;
 891     V_I4(&vararg[0]) = 0x80000005;
 892     dispparams.cNamedArgs = 0;
 893     dispparams.cArgs = 1;
 894     dispparams.rgdispidNamedArgs = NULL;
 895     dispparams.rgvarg = vararg;
 896     hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
 897     ok_ole_success(hr, IDispatch_Invoke);
 898
 899     /* call GetOleColor */
 900     dispparams.cNamedArgs = 0;
 901     dispparams.cArgs = 0;
 902     dispparams.rgdispidNamedArgs = NULL;
 903     dispparams.rgvarg = NULL;
 904     VariantInit(&varresult);
 905     hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 906     ok_ole_success(hr, IDispatch_Invoke);
 907     VariantClear(&varresult);
 908
 909     /* call Clone */
 910     dispparams.cNamedArgs = 0;
 911     dispparams.cArgs = 0;
 912     dispparams.rgdispidNamedArgs = NULL;
 913     dispparams.rgvarg = NULL;
 914     VariantInit(&varresult);
 915     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 916     ok_ole_success(hr, IDispatch_Invoke);
 917     VariantClear(&varresult);
 918
 919     /* call CloneDispatch with automatic value getting */
 920     V_VT(&vararg[0]) = VT_I2;
 921     V_I2(&vararg[0]) = 1;
 922     dispparams.cNamedArgs = 0;
 923     dispparams.rgdispidNamedArgs = NULL;
 924     dispparams.cArgs = 1;
 925     dispparams.rgvarg = vararg;
 926     VariantInit(&varresult);
 927     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 928     ok_ole_success(hr, IDispatch_Invoke);
 929
 930     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 931         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 932         excepinfo.wCode, excepinfo.scode);
 933
 934     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
 935     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
 936     VariantClear(&varresult);
 937
 938     /* call CloneCoclass */
 939     dispparams.cNamedArgs = 0;
 940     dispparams.cArgs = 0;
 941     dispparams.rgdispidNamedArgs = NULL;
 942     dispparams.rgvarg = NULL;
 943     VariantInit(&varresult);
 944     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 945     ok_ole_success(hr, IDispatch_Invoke);
 946
 947     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 948        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 949        excepinfo.wCode, excepinfo.scode);
 950
 951     ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
 952     ok(!V_DISPATCH(&varresult), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult));
 953     VariantClear(&varresult);
 954
 955     /* call Value with a VT_VARIANT|VT_BYREF type */
 956     V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
 957     V_VARIANTREF(&vararg[0]) = &vararg[1];
 958     V_VT(&vararg[1]) = VT_I2;
 959     V_I2(&vararg[1]) = 1;
 960     dispparams.cNamedArgs = 0;
 961     dispparams.rgdispidNamedArgs = NULL;
 962     dispparams.cArgs = 1;
 963     dispparams.rgvarg = vararg;
 964     VariantInit(&varresult);
 965     hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 966     ok_ole_success(hr, IDispatch_Invoke);
 967
 968     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
 969         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
 970         excepinfo.wCode, excepinfo.scode);
 971
 972     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
 973     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
 974     VariantClear(&varresult);
 975
 976     /* call Variant - exercises variant copying in ITypeInfo::Invoke and
 977      * handling of void return types */
 978     /* use a big type to ensure that the variant was properly copied into the
 979      * destination function's args */
 980     V_VT(&vararg[0]) = VT_CY;
 981     S(V_CY(&vararg[0])).Hi = 0xdababe;
 982     S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
 983     dispparams.cNamedArgs = 0;
 984     dispparams.cArgs = 1;
 985     dispparams.rgdispidNamedArgs = NULL;
 986     dispparams.rgvarg = vararg;
 987     VariantInit(&varresult);
 988     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 989     ok_ole_success(hr, IDispatch_Invoke);
 990     VariantClear(&varresult);
 991
 992     /* call VarArg */
 993     VariantInit(&vararg[3]);
 994     V_VT(&vararg[3]) = VT_I4;
 995     V_I4(&vararg[3]) = 3;
 996     VariantInit(&vararg[2]);
 997     V_VT(&vararg[2]) = VT_I4;
 998     V_I4(&vararg[2]) = 0;
 999     VariantInit(&vararg[1]);
1000     V_VT(&vararg[1]) = VT_I4;
1001     V_I4(&vararg[1]) = 1;
1002     VariantInit(&vararg[0]);
1003     V_VT(&vararg[0]) = VT_I4;
1004     V_I4(&vararg[0]) = 2;
1005     dispparams.cNamedArgs = 0;
1006     dispparams.cArgs = 4;
1007     dispparams.rgdispidNamedArgs = NULL;
1008     dispparams.rgvarg = vararg;
1009     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1010     ok_ole_success(hr, ITypeInfo_Invoke);
1011
1012     /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1013     dispidNamed = 0;
1014     dispparams.cNamedArgs = 1;
1015     dispparams.rgdispidNamedArgs = &dispidNamed;
1016     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1017     ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
1018     dispidNamed = DISPID_PROPERTYPUT;
1019
1020     /* call Error */
1021     dispparams.cNamedArgs = 0;
1022     dispparams.cArgs = 0;
1023     dispparams.rgdispidNamedArgs = NULL;
1024     dispparams.rgvarg = NULL;
1025     VariantInit(&varresult);
1026     hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1027     ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1028     ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1029         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1030         excepinfo.wCode, excepinfo.scode);
1031     VariantClear(&varresult);
1032
1033     /* call BstrRet */
1034     pTypeInfo = NonOleAutomation_GetTypeInfo();
1035     dispparams.cNamedArgs = 0;
1036     dispparams.cArgs = 0;
1037     dispparams.rgdispidNamedArgs = NULL;
1038     dispparams.rgvarg = NULL;
1039     VariantInit(&varresult);
1040     hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1041     ok_ole_success(hr, ITypeInfo_Invoke);
1042     ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
1043     ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
1044
1045     VariantClear(&varresult);
1046     ITypeInfo_Release(pTypeInfo);
1047
1048     /* tests call put_Name without named arg */
1049     VariantInit(&vararg[0]);
1050     dispparams.cNamedArgs = 0;
1051     dispparams.rgdispidNamedArgs = NULL;
1052     dispparams.cArgs = 1;
1053     dispparams.rgvarg = vararg;
1054     VariantInit(&varresult);
1055     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1056     ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
1057     VariantClear(&varresult);
1058
1059     /* tests param type that cannot be coerced */
1060     VariantInit(&vararg[0]);
1061     V_VT(&vararg[0]) = VT_UNKNOWN;
1062     V_UNKNOWN(&vararg[0]) = NULL;
1063     dispparams.cNamedArgs = 1;
1064     dispparams.rgdispidNamedArgs = &dispidNamed;
1065     dispparams.cArgs = 1;
1066     dispparams.rgvarg = vararg;
1067     VariantInit(&varresult);
1068 #if 0 /* NULL unknown not currently marshaled correctly */
1069     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1070     ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1071 #endif
1072     VariantClear(&varresult);
1073
1074     /* tests bad param type */
1075     VariantInit(&vararg[0]);
1076     V_VT(&vararg[0]) = VT_CLSID;
1077     V_BYREF(&vararg[0]) = NULL;
1078     dispparams.cNamedArgs = 1;
1079     dispparams.rgdispidNamedArgs = &dispidNamed;
1080     dispparams.cArgs = 1;
1081     dispparams.rgvarg = vararg;
1082     VariantInit(&varresult);
1083     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1084     ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1085     VariantClear(&varresult);
1086
1087     /* tests too small param count */
1088     dispparams.cNamedArgs = 0;
1089     dispparams.rgdispidNamedArgs = NULL;
1090     dispparams.cArgs = 0;
1091     dispparams.rgvarg = NULL;
1092     VariantInit(&varresult);
1093     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1094     ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1095     VariantClear(&varresult);
1096
1097     /* tests propget function with large param count */
1098     VariantInit(&vararg[0]);
1099     V_VT(&vararg[0]) = VT_BSTR;
1100     V_BSTR(&vararg[0]) = NULL;
1101     V_VT(&vararg[1]) = VT_I4;
1102     V_I4(&vararg[1]) = 1;
1103     dispparams.cNamedArgs = 0;
1104     dispparams.cArgs = 2;
1105     dispparams.rgdispidNamedArgs = NULL;
1106     dispparams.rgvarg = vararg;
1107     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1108     ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1109
1110     IDispatch_Release(pDispatch);
1111     IWidget_Release(pWidget);
1112
1113     trace("calling end_host_object\n");
1114     end_host_object(tid, thread);
1115 }
1116
1117 static void test_DispCallFunc(void)
1118 {
1119     static const WCHAR szEmpty[] = { 0 };
1120     VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1121     VARIANTARG vararg[4];
1122     VARIANTARG varref;
1123     VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1124     VARIANTARG varresult;
1125     HRESULT hr;
1126     IWidget *pWidget = Widget_Create();
1127     V_VT(&vararg[0]) = VT_R8;
1128     V_R8(&vararg[0]) = 3.141;
1129     V_VT(&vararg[1]) = VT_BSTR;
1130     V_BSTR(&vararg[1]) = SysAllocString(szEmpty);
1131     V_VT(&vararg[2]) = VT_BSTR;
1132     V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1133     V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1134     V_VARIANTREF(&vararg[3]) = &varref;
1135     V_VT(&varref) = VT_ERROR;
1136     V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1137     VariantInit(&varresult);
1138     hr = DispCallFunc(pWidget, 36, CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1139     ok_ole_success(hr, DispCallFunc);
1140     VariantClear(&varresult);
1141 }
1142
1143 START_TEST(tmarshal)
1144 {
1145     HRESULT hr;
1146
1147     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1148
1149     hr = register_current_module_typelib();
1150     ok_ole_success(hr, register_current_module_typelib);
1151
1152     test_typelibmarshal();
1153     test_DispCallFunc();
1154
1155     CoUninitialize();
1156 }