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