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

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