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 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
  33
  34
  35 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
  36
  37 /* ULL suffix is not portable */
  38 #define ULL_CONST(dw1, dw2) ((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)
  39
  40 const MYSTRUCT MYSTRUCT_BYVAL = {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432), {0,1,2,3,4,5,6,7}};
  41 const MYSTRUCT MYSTRUCT_BYPTR = {0x91827364, ULL_CONST(0x88776655, 0x44332211), {0,1,2,3,4,5,6,7}};
  42 const MYSTRUCT MYSTRUCT_ARRAY[5] = {
  43     {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415), {0,1,2,3,4,5,6,7}},
  44     {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425), {0,1,2,3,4,5,6,7}},
  45     {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435), {0,1,2,3,4,5,6,7}},
  46     {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445), {0,1,2,3,4,5,6,7}},
  47     {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455), {0,1,2,3,4,5,6,7}},
  48 };
  49
  50
  51 #define RELEASEMARSHALDATA WM_USER
  52
  53 struct host_object_data
  54 {
  55     IStream *stream;
  56     IID iid;
  57     IUnknown *object;
  58     MSHLFLAGS marshal_flags;
  59     HANDLE marshal_event;
  60     IMessageFilter *filter;
  61 };
  62
  63 static DWORD CALLBACK host_object_proc(LPVOID p)
  64 {
  65     struct host_object_data *data = p;
  66     HRESULT hr;
  67     MSG msg;
  68
  69     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
  70
  71     if (data->filter)
  72     {
  73         IMessageFilter * prev_filter = NULL;
  74         hr = CoRegisterMessageFilter(data->filter, &prev_filter);
  75         if (prev_filter) IMessageFilter_Release(prev_filter);
  76         ok_ole_success(hr, CoRegisterMessageFilter);
  77     }
  78
  79     hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
  80     ok_ole_success(hr, CoMarshalInterface);
  81
  82     /* force the message queue to be created before signaling parent thread */
  83     PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
  84
  85     SetEvent(data->marshal_event);
  86
  87     while (GetMessageA(&msg, NULL, 0, 0))
  88     {
  89         if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
  90         {
  91             trace("releasing marshal data\n");
  92             CoReleaseMarshalData(data->stream);
  93             SetEvent((HANDLE)msg.lParam);
  94         }
  95         else
  96             DispatchMessageA(&msg);
  97     }
  98
  99     HeapFree(GetProcessHeap(), 0, data);
 100
 101     CoUninitialize();
 102
 103     return hr;
 104 }
 105
 106 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
 107 {
 108     DWORD tid = 0;
 109     HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
 110     struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 111
 112     data->stream = stream;
 113     data->iid = *riid;
 114     data->object = object;
 115     data->marshal_flags = marshal_flags;
 116     data->marshal_event = marshal_event;
 117     data->filter = filter;
 118
 119     *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 120
 121     /* wait for marshaling to complete before returning */
 122     WaitForSingleObject(marshal_event, INFINITE);
 123     CloseHandle(marshal_event);
 124
 125     return tid;
 126 }
 127
 128 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
 129 {
 130     return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
 131 }
 132
 133 #if 0 /* not used */
 134 /* asks thread to release the marshal data because it has to be done by the
 135  * same thread that marshaled the interface in the first place. */
 136 static void release_host_object(DWORD tid)
 137 {
 138     HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);
 139     PostThreadMessageA(tid, RELEASEMARSHALDATA, 0, (LPARAM)event);
 140     WaitForSingleObject(event, INFINITE);
 141     CloseHandle(event);
 142 }
 143 #endif
 144
 145 static void end_host_object(DWORD tid, HANDLE thread)
 146 {
 147     BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
 148     ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
 149     /* be careful of races - don't return until hosting thread has terminated */
 150     WaitForSingleObject(thread, INFINITE);
 151     CloseHandle(thread);
 152 }
 153
 154 static int external_connections;
 155 static BOOL expect_last_release_closes;
 156
 157 static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv)
 158 {
 159     ok(0, "unexpected call\n");
 160     *ppv = NULL;
 161     return E_NOINTERFACE;
 162 }
 163
 164 static ULONG WINAPI ExternalConnection_AddRef(IExternalConnection *iface)
 165 {
 166     return 2;
 167 }
 168
 169 static ULONG WINAPI ExternalConnection_Release(IExternalConnection *iface)
 170 {
 171     return 1;
 172 }
 173
 174 static DWORD WINAPI ExternalConnection_AddConnection(IExternalConnection *iface, DWORD extconn, DWORD reserved)
 175 {
 176     trace("add connection\n");
 177
 178     ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
 179     ok(!reserved, "reserved = %x\n", reserved);
 180     return ++external_connections;
 181 }
 182
 183 static DWORD WINAPI ExternalConnection_ReleaseConnection(IExternalConnection *iface, DWORD extconn,
 184         DWORD reserved, BOOL fLastReleaseCloses)
 185 {
 186     trace("release connection\n");
 187
 188     ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
 189     ok(!reserved, "reserved = %x\n", reserved);
 190
 191     ok(fLastReleaseCloses == expect_last_release_closes, "fLastReleaseCloses = %x, expected %x\n",
 192        fLastReleaseCloses, expect_last_release_closes);
 193     return --external_connections;
 194 }
 195
 196 static const IExternalConnectionVtbl ExternalConnectionVtbl = {
 197     ExternalConnection_QueryInterface,
 198     ExternalConnection_AddRef,
 199     ExternalConnection_Release,
 200     ExternalConnection_AddConnection,
 201     ExternalConnection_ReleaseConnection
 202 };
 203
 204 static IExternalConnection ExternalConnection = { &ExternalConnectionVtbl };
 205
 206 static ItestDual TestDual, TestDualDisp;
 207
 208 static HRESULT WINAPI TestSecondIface_QueryInterface(ITestSecondIface *iface, REFIID riid, void **ppv)
 209 {
 210     return ItestDual_QueryInterface(&TestDual, riid, ppv);
 211 }
 212
 213 static ULONG WINAPI TestSecondIface_AddRef(ITestSecondIface *iface)
 214 {
 215     return 2;
 216 }
 217
 218 static ULONG WINAPI TestSecondIface_Release(ITestSecondIface *iface)
 219 {
 220     return 1;
 221 }
 222
 223 static HRESULT WINAPI TestSecondIface_test(ITestSecondIface *iface)
 224 {
 225     return 1;
 226 }
 227
 228 static const ITestSecondIfaceVtbl TestSecondIfaceVtbl = {
 229     TestSecondIface_QueryInterface,
 230     TestSecondIface_AddRef,
 231     TestSecondIface_Release,
 232     TestSecondIface_test
 233 };
 234
 235 static ITestSecondIface TestSecondIface = { &TestSecondIfaceVtbl };
 236
 237 static HRESULT WINAPI TestSecondDisp_QueryInterface(ITestSecondDisp *iface, REFIID riid, void **ppv)
 238 {
 239     return ItestDual_QueryInterface(&TestDual, riid, ppv);
 240 }
 241
 242 static ULONG WINAPI TestSecondDisp_AddRef(ITestSecondDisp *iface)
 243 {
 244     return 2;
 245 }
 246
 247 static ULONG WINAPI TestSecondDisp_Release(ITestSecondDisp *iface)
 248 {
 249     return 1;
 250 }
 251
 252 static HRESULT WINAPI TestSecondDisp_GetTypeInfoCount(ITestSecondDisp *iface, UINT *pctinfo)
 253 {
 254     ok(0, "unexpected call\n");
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI TestSecondDisp_GetTypeInfo(ITestSecondDisp *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 259 {
 260     ok(0, "unexpected call\n");
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI TestSecondDisp_GetIDsOfNames(ITestSecondDisp *iface, REFIID riid, LPOLESTR *rgszNames,
 265         UINT cNames, LCID lcid, DISPID *rgDispId)
 266 {
 267     ok(0, "unexpected call\n");
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI TestSecondDisp_Invoke(ITestSecondDisp *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 272         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 273         UINT *puArgErr)
 274 {
 275     ok(0, "unexpected call\n");
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI TestSecondDisp_test(ITestSecondDisp *iface)
 280 {
 281     ok(0, "unexpected call\n");
 282     return E_NOTIMPL;
 283 }
 284
 285 static ITestSecondDispVtbl TestSecondDispVtbl = {
 286     TestSecondDisp_QueryInterface,
 287     TestSecondDisp_AddRef,
 288     TestSecondDisp_Release,
 289     TestSecondDisp_GetTypeInfoCount,
 290     TestSecondDisp_GetTypeInfo,
 291     TestSecondDisp_GetIDsOfNames,
 292     TestSecondDisp_Invoke,
 293     TestSecondDisp_test
 294 };
 295
 296 static ITestSecondDisp TestSecondDisp = { &TestSecondDispVtbl };
 297
 298 static HRESULT WINAPI TestDual_QueryInterface(ItestDual *iface, REFIID riid, void **ppvObject)
 299 {
 300     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch)) {
 301         *ppvObject = &TestDualDisp;
 302         return S_OK;
 303     }else if(IsEqualGUID(riid, &IID_ItestDual)) {
 304         *ppvObject = &TestDual;
 305         return S_OK;
 306     }else if(IsEqualGUID(riid, &IID_ITestSecondIface)) {
 307         *ppvObject = &TestSecondIface;
 308         return S_OK;
 309     }else if(IsEqualGUID(riid, &IID_ITestSecondDisp)) {
 310         *ppvObject = &TestSecondDisp;
 311         return S_OK;
 312     }else if (IsEqualGUID(riid, &IID_IExternalConnection)) {
 313         trace("QI external connection\n");
 314         *ppvObject = &ExternalConnection;
 315         return S_OK;
 316     }
 317
 318     *ppvObject = NULL;
 319     return E_NOINTERFACE;
 320 }
 321
 322 static ULONG WINAPI TestDual_AddRef(ItestDual *iface)
 323 {
 324     return 2;
 325 }
 326
 327 static ULONG WINAPI TestDual_Release(ItestDual *iface)
 328 {
 329     return 1;
 330 }
 331
 332 static HRESULT WINAPI TestDual_GetTypeInfoCount(ItestDual *iface, UINT *pctinfo)
 333 {
 334     ok(0, "unexpected call\n");
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI TestDual_GetTypeInfo(ItestDual *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 339 {
 340     ok(0, "unexpected call\n");
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI TestDual_GetIDsOfNames(ItestDual *iface, REFIID riid, LPOLESTR *rgszNames,
 345         UINT cNames, LCID lcid, DISPID *rgDispId)
 346 {
 347     ok(0, "unexpected call\n");
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI TestDual_Invoke(ItestDual *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 352         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 353         UINT *puArgErr)
 354 {
 355     ok(0, "unexpected call\n");
 356     return E_NOTIMPL;
 357 }
 358
 359 static ItestDualVtbl TestDualVtbl = {
 360     TestDual_QueryInterface,
 361     TestDual_AddRef,
 362     TestDual_Release,
 363     TestDual_GetTypeInfoCount,
 364     TestDual_GetTypeInfo,
 365     TestDual_GetIDsOfNames,
 366     TestDual_Invoke
 367 };
 368
 369 static ItestDual TestDual = { &TestDualVtbl };
 370 static ItestDual TestDualDisp = { &TestDualVtbl };
 371
 372 typedef struct Widget
 373 {
 374     IWidget IWidget_iface;
 375     LONG refs;
 376     IUnknown *pDispatchUnknown;
 377 } Widget;
 378
 379 static inline Widget *impl_from_IWidget(IWidget *iface)
 380 {
 381     return CONTAINING_RECORD(iface, Widget, IWidget_iface);
 382 }
 383
 384 static HRESULT WINAPI Widget_QueryInterface(
 385     IWidget *iface,
 386     /* [in] */ REFIID riid,
 387     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 388 {
 389     if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 390     {
 391         IWidget_AddRef(iface);
 392         *ppvObject = iface;
 393         return S_OK;
 394     }
 395     else
 396     {
 397         *ppvObject = NULL;
 398         return E_NOINTERFACE;
 399     }
 400 }
 401
 402 static ULONG WINAPI Widget_AddRef(
 403     IWidget *iface)
 404 {
 405     Widget *This = impl_from_IWidget(iface);
 406
 407     return InterlockedIncrement(&This->refs);
 408 }
 409
 410 static ULONG WINAPI Widget_Release(
 411     IWidget *iface)
 412 {
 413     Widget *This = impl_from_IWidget(iface);
 414     ULONG refs = InterlockedDecrement(&This->refs);
 415     if (!refs)
 416     {
 417         IUnknown_Release(This->pDispatchUnknown);
 418         memset(This, 0xcc, sizeof(*This));
 419         HeapFree(GetProcessHeap(), 0, This);
 420         trace("Widget destroyed!\n");
 421     }
 422
 423     return refs;
 424 }
 425
 426 static HRESULT WINAPI Widget_GetTypeInfoCount(
 427     IWidget *iface,
 428     /* [out] */ UINT __RPC_FAR *pctinfo)
 429 {
 430     Widget *This = impl_from_IWidget(iface);
 431     IDispatch *pDispatch;
 432     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 433     if (SUCCEEDED(hr))
 434     {
 435         hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
 436         IDispatch_Release(pDispatch);
 437     }
 438     return hr;
 439 }
 440
 441 static HRESULT WINAPI Widget_GetTypeInfo(
 442     IWidget __RPC_FAR * iface,
 443     /* [in] */ UINT iTInfo,
 444     /* [in] */ LCID lcid,
 445     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
 446 {
 447     Widget *This = impl_from_IWidget(iface);
 448     IDispatch *pDispatch;
 449     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 450     if (SUCCEEDED(hr))
 451     {
 452         hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
 453         IDispatch_Release(pDispatch);
 454     }
 455     return hr;
 456 }
 457
 458 static HRESULT WINAPI Widget_GetIDsOfNames(
 459     IWidget __RPC_FAR * iface,
 460     /* [in] */ REFIID riid,
 461     /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
 462     /* [in] */ UINT cNames,
 463     /* [in] */ LCID lcid,
 464     /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
 465 {
 466     Widget *This = impl_from_IWidget(iface);
 467     IDispatch *pDispatch;
 468     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 469     if (SUCCEEDED(hr))
 470     {
 471         hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
 472         IDispatch_Release(pDispatch);
 473     }
 474     return hr;
 475 }
 476
 477 static HRESULT WINAPI Widget_Invoke(
 478     IWidget __RPC_FAR * iface,
 479     /* [in] */ DISPID dispIdMember,
 480     /* [in] */ REFIID riid,
 481     /* [in] */ LCID lcid,
 482     /* [in] */ WORD wFlags,
 483     /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
 484     /* [out] */ VARIANT __RPC_FAR *pVarResult,
 485     /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
 486     /* [out] */ UINT __RPC_FAR *puArgErr)
 487 {
 488     Widget *This = impl_from_IWidget(iface);
 489     IDispatch *pDispatch;
 490     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 491     if (SUCCEEDED(hr))
 492     {
 493         hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 494         IDispatch_Release(pDispatch);
 495     }
 496     return hr;
 497 }
 498
 499 static HRESULT WINAPI Widget_put_Name(
 500     IWidget __RPC_FAR * iface,
 501     /* [in] */ BSTR name)
 502 {
 503     trace("put_Name(%s)\n", wine_dbgstr_w(name));
 504     return S_OK;
 505 }
 506
 507 static HRESULT WINAPI Widget_get_Name(
 508     IWidget __RPC_FAR * iface,
 509     /* [out] */ BSTR __RPC_FAR *name)
 510 {
 511     static const WCHAR szCat[] = { 'C','a','t',0 };
 512     trace("get_Name()\n");
 513     *name = SysAllocString(szCat);
 514     return S_OK;
 515 }
 516
 517 static HRESULT WINAPI Widget_DoSomething(
 518     IWidget __RPC_FAR * iface,
 519     /* [in] */ double number,
 520     /* [out] */ BSTR *str1,
 521     /* [defaultvalue][in] */ BSTR str2,
 522     /* [optional][in] */ VARIANT __RPC_FAR *opt)
 523 {
 524     static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
 525     trace("DoSomething()\n");
 526
 527     ok(number == 3.141, "number(%f) != 3.141\n", number);
 528     ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
 529     ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
 530     ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
 531     *str1 = SysAllocString(szString);
 532
 533     return S_FALSE;
 534 }
 535
 536 static HRESULT WINAPI Widget_get_State(
 537     IWidget __RPC_FAR * iface,
 538     /* [retval][out] */ STATE __RPC_FAR *state)
 539 {
 540     trace("get_State() = STATE_WIDGETIFIED\n");
 541     *state = STATE_WIDGETIFIED;
 542     return S_OK;
 543 }
 544
 545 static HRESULT WINAPI Widget_put_State(
 546     IWidget __RPC_FAR * iface,
 547     /* [in] */ STATE state)
 548 {
 549     trace("put_State(%d)\n", state);
 550     return S_OK;
 551 }
 552
 553 static HRESULT WINAPI Widget_Map(
 554     IWidget * iface,
 555     BSTR bstrId,
 556     BSTR *sValue)
 557 {
 558     trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
 559     *sValue = SysAllocString(bstrId);
 560     return S_OK;
 561 }
 562
 563 static HRESULT WINAPI Widget_SetOleColor(
 564     IWidget * iface,
 565     OLE_COLOR val)
 566 {
 567     trace("SetOleColor(0x%x)\n", val);
 568     return S_OK;
 569 }
 570
 571 static HRESULT WINAPI Widget_GetOleColor(
 572     IWidget * iface,
 573     OLE_COLOR *pVal)
 574 {
 575     trace("GetOleColor() = 0x8000000f\n");
 576     *pVal = 0x8000000f;
 577     return S_FALSE;
 578 }
 579
 580 static HRESULT WINAPI Widget_Clone(
 581     IWidget *iface,
 582     IWidget **ppVal)
 583 {
 584     trace("Clone()\n");
 585     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 586 }
 587
 588 static HRESULT WINAPI Widget_CloneDispatch(
 589     IWidget *iface,
 590     IDispatch **ppVal)
 591 {
 592     trace("CloneDispatch()\n");
 593     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 594 }
 595
 596 static HRESULT WINAPI Widget_CloneCoclass(
 597     IWidget *iface,
 598     ApplicationObject2 **ppVal)
 599 {
 600     trace("CloneCoclass()\n");
 601     return S_OK;
 602 }
 603
 604 static HRESULT WINAPI Widget_Value(
 605     IWidget __RPC_FAR * iface,
 606     VARIANT *value,
 607     VARIANT *retval)
 608 {
 609     trace("Value(%p, %p)\n", value, retval);
 610     ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
 611     ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
 612     V_VT(retval) = VT_I2;
 613     V_I2(retval) = 1234;
 614     return S_OK;
 615 }
 616
 617 static HRESULT WINAPI Widget_Array(
 618     IWidget * iface,
 619     SAFEARRAY * values)
 620 {
 621     trace("Array(%p)\n", values);
 622     return S_OK;
 623 }
 624
 625 static HRESULT WINAPI Widget_VariantArrayPtr(
 626     IWidget * iface,
 627     SAFEARRAY ** values)
 628 {
 629     trace("VariantArrayPtr(%p)\n", values);
 630     return S_OK;
 631 }
 632
 633 static HRESULT WINAPI Widget_VariantCArray(
 634     IWidget * iface,
 635     ULONG count,
 636     VARIANT values[])
 637 {
 638     ULONG i;
 639
 640     trace("VariantCArray(%u,%p)\n", count, values);
 641
 642     ok(count == 2, "count is %d\n", count);
 643     for (i = 0; i < count; i++)
 644         ok(V_VT(&values[i]) == VT_I4, "values[%d] is not VT_I4\n", i);
 645
 646     if (pVarAdd)
 647     {
 648         VARIANT inc, res;
 649         HRESULT hr;
 650
 651         V_VT(&inc) = VT_I4;
 652         V_I4(&inc) = 1;
 653         for (i = 0; i < count; i++) {
 654             VariantInit(&res);
 655             hr = pVarAdd(&values[i], &inc, &res);
 656             if (FAILED(hr)) {
 657                 ok(0, "VarAdd failed at %u with error 0x%x\n", i, hr);
 658                 return hr;
 659             }
 660             hr = VariantCopy(&values[i], &res);
 661             if (FAILED(hr)) {
 662                 ok(0, "VariantCopy failed at %u with error 0x%x\n", i, hr);
 663                 return hr;
 664             }
 665         }
 666     }
 667     else
 668         win_skip("VarAdd is not available\n");
 669
 670     return S_OK;
 671 }
 672
 673 static HRESULT WINAPI Widget_Variant(
 674     IWidget __RPC_FAR * iface,
 675     VARIANT var)
 676 {
 677     trace("Variant()\n");
 678     ok(V_VT(&var) == VT_CY, "V_VT(&var) was %d\n", V_VT(&var));
 679     ok(S(V_CY(&var)).Hi == 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var)).Hi);
 680     ok(S(V_CY(&var)).Lo == 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var)).Lo);
 681     return S_OK;
 682 }
 683
 684 static HRESULT WINAPI Widget_VarArg(
 685     IWidget * iface,
 686     int numexpect,
 687     SAFEARRAY * values)
 688 {
 689     LONG lbound, ubound, i;
 690     VARIANT * data;
 691     HRESULT hr;
 692
 693     trace("VarArg(%p)\n", values);
 694
 695     hr = SafeArrayGetLBound(values, 1, &lbound);
 696     ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
 697     ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
 698
 699     hr = SafeArrayGetUBound(values, 1, &ubound);
 700     ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
 701     ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
 702
 703     hr = SafeArrayAccessData(values, (LPVOID)&data);
 704     ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 705
 706     for (i=0; i<=ubound-lbound; i++)
 707     {
 708         ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
 709         ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
 710     }
 711
 712     hr = SafeArrayUnaccessData(values);
 713     ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
 714
 715     return S_OK;
 716 }
 717
 718
 719 static BOOL mystruct_uint_ordered(MYSTRUCT *mystruct)
 720 {
 721     int i;
 722     for (i = 0; i < sizeof(mystruct->uarr)/sizeof(mystruct->uarr[0]); i++)
 723         if (mystruct->uarr[i] != i)
 724             return FALSE;
 725     return TRUE;
 726 }
 727
 728 static HRESULT WINAPI Widget_StructArgs(
 729     IWidget * iface,
 730     MYSTRUCT byval,
 731     MYSTRUCT *byptr,
 732     MYSTRUCT arr[5])
 733 {
 734     int i, diff = 0;
 735     ok(byval.field1 == MYSTRUCT_BYVAL.field1 &&
 736        byval.field2 == MYSTRUCT_BYVAL.field2 &&
 737        mystruct_uint_ordered(&byval),
 738        "Struct parameter passed by value corrupted\n");
 739     ok(byptr->field1 == MYSTRUCT_BYPTR.field1 &&
 740        byptr->field2 == MYSTRUCT_BYPTR.field2 &&
 741        mystruct_uint_ordered(byptr),
 742        "Struct parameter passed by pointer corrupted\n");
 743     for (i = 0; i < 5; i++)
 744         if (arr[i].field1 != MYSTRUCT_ARRAY[i].field1 ||
 745             arr[i].field2 != MYSTRUCT_ARRAY[i].field2 ||
 746             ! mystruct_uint_ordered(&arr[i]))
 747             diff++;
 748     ok(diff == 0, "Array of structs corrupted\n");
 749     return S_OK;
 750 }
 751
 752
 753 static HRESULT WINAPI Widget_Error(
 754     IWidget __RPC_FAR * iface)
 755 {
 756     trace("Error()\n");
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI Widget_CloneInterface(
 761     IWidget __RPC_FAR * iface,
 762     ISomethingFromDispatch **ppVal)
 763 {
 764     trace("CloneInterface()\n");
 765     *ppVal = 0;
 766     return S_OK;
 767 }
 768
 769 static HRESULT WINAPI Widget_put_prop_with_lcid(
 770     IWidget* iface, LONG lcid, INT i)
 771 {
 772     trace("put_prop_with_lcid(%08x, %x)\n", lcid, i);
 773     ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
 774     ok(i == 0xcafe, "got %08x\n", i);
 775     return S_OK;
 776 }
 777
 778 static HRESULT WINAPI Widget_get_prop_with_lcid(
 779     IWidget* iface, LONG lcid, INT *i)
 780 {
 781     trace("get_prop_with_lcid(%08x, %p)\n", lcid, i);
 782     ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
 783     *i = lcid;
 784     return S_OK;
 785 }
 786
 787 static HRESULT WINAPI Widget_get_prop_int(
 788     IWidget* iface, INT *i)
 789 {
 790     trace("get_prop_int(%p)\n", i);
 791     *i = -13;
 792     return S_OK;
 793 }
 794
 795 static HRESULT WINAPI Widget_get_prop_uint(
 796     IWidget* iface, UINT *i)
 797 {
 798     trace("get_prop_uint(%p)\n", i);
 799     *i = 42;
 800     return S_OK;
 801 }
 802
 803 static HRESULT WINAPI Widget_ByRefUInt(
 804     IWidget* iface, UINT *i)
 805 {
 806     *i = 42;
 807     return S_OK;
 808 }
 809
 810 static HRESULT WINAPI Widget_put_prop_opt_arg(
 811     IWidget* iface, INT opt, INT i)
 812 {
 813     trace("put_prop_opt_arg(%08x, %08x)\n", opt, i);
 814     todo_wine ok(opt == 0, "got opt=%08x\n", opt);
 815     ok(i == 0xcafe, "got i=%08x\n", i);
 816     return S_OK;
 817 }
 818
 819 static HRESULT WINAPI Widget_put_prop_req_arg(
 820     IWidget* iface, INT req, INT i)
 821 {
 822     trace("put_prop_req_arg(%08x, %08x)\n", req, i);
 823     ok(req == 0x5678, "got req=%08x\n", req);
 824     ok(i == 0x1234, "got i=%08x\n", i);
 825     return S_OK;
 826 }
 827
 828 static HRESULT WINAPI Widget_pos_restrict(IWidget* iface, INT *i)
 829 {
 830     trace("restrict\n");
 831     *i = DISPID_TM_RESTRICTED;
 832     return S_OK;
 833 }
 834
 835 static HRESULT WINAPI Widget_neg_restrict(IWidget* iface, INT *i)
 836 {
 837     trace("neg_restrict\n");
 838     *i = DISPID_TM_NEG_RESTRICTED;
 839     return S_OK;
 840 }
 841
 842 static HRESULT WINAPI Widget_VarArg_Run(
 843     IWidget *iface, BSTR name, SAFEARRAY *params, VARIANT *result)
 844 {
 845     static const WCHAR catW[] = { 'C','a','t',0 };
 846     static const WCHAR supermanW[] = { 'S','u','p','e','r','m','a','n',0 };
 847     LONG bound;
 848     VARIANT *var;
 849     BSTR bstr;
 850     HRESULT hr;
 851
 852     trace("VarArg_Run(%p,%p,%p)\n", name, params, result);
 853
 854     ok(!lstrcmpW(name, catW), "got %s\n", wine_dbgstr_w(name));
 855
 856     hr = SafeArrayGetLBound(params, 1, &bound);
 857     ok(hr == S_OK, "SafeArrayGetLBound error %#x\n", hr);
 858     ok(bound == 0, "expected 0, got %d\n", bound);
 859
 860     hr = SafeArrayGetUBound(params, 1, &bound);
 861     ok(hr == S_OK, "SafeArrayGetUBound error %#x\n", hr);
 862     ok(bound == 0, "expected 0, got %d\n", bound);
 863
 864     hr = SafeArrayAccessData(params, (void **)&var);
 865     ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 866
 867     ok(V_VT(&var[0]) == VT_BSTR, "expected VT_BSTR, got %d\n", V_VT(&var[0]));
 868     bstr = V_BSTR(&var[0]);
 869     ok(!lstrcmpW(bstr, supermanW), "got %s\n", wine_dbgstr_w(bstr));
 870
 871     hr = SafeArrayUnaccessData(params);
 872     ok(hr == S_OK, "SafeArrayUnaccessData error %#x\n", hr);
 873
 874     return S_OK;
 875 }
 876
 877 static const struct IWidgetVtbl Widget_VTable =
 878 {
 879     Widget_QueryInterface,
 880     Widget_AddRef,
 881     Widget_Release,
 882     Widget_GetTypeInfoCount,
 883     Widget_GetTypeInfo,
 884     Widget_GetIDsOfNames,
 885     Widget_Invoke,
 886     Widget_put_Name,
 887     Widget_get_Name,
 888     Widget_DoSomething,
 889     Widget_get_State,
 890     Widget_put_State,
 891     Widget_Map,
 892     Widget_SetOleColor,
 893     Widget_GetOleColor,
 894     Widget_Clone,
 895     Widget_CloneDispatch,
 896     Widget_CloneCoclass,
 897     Widget_Value,
 898     Widget_Array,
 899     Widget_VariantArrayPtr,
 900     Widget_VariantCArray,
 901     Widget_Variant,
 902     Widget_VarArg,
 903     Widget_StructArgs,
 904     Widget_Error,
 905     Widget_CloneInterface,
 906     Widget_put_prop_with_lcid,
 907     Widget_get_prop_with_lcid,
 908     Widget_get_prop_int,
 909     Widget_get_prop_uint,
 910     Widget_ByRefUInt,
 911     Widget_put_prop_opt_arg,
 912     Widget_put_prop_req_arg,
 913     Widget_pos_restrict,
 914     Widget_neg_restrict,
 915     Widget_VarArg_Run
 916 };
 917
 918 static HRESULT WINAPI StaticWidget_QueryInterface(IStaticWidget *iface, REFIID riid, void **ppvObject)
 919 {
 920     if (IsEqualIID(riid, &IID_IStaticWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 921     {
 922         IStaticWidget_AddRef(iface);
 923         *ppvObject = iface;
 924         return S_OK;
 925     }
 926
 927     *ppvObject = NULL;
 928     return E_NOINTERFACE;
 929 }
 930
 931 static ULONG WINAPI StaticWidget_AddRef(IStaticWidget *iface)
 932 {
 933     return 2;
 934 }
 935
 936 static ULONG WINAPI StaticWidget_Release(IStaticWidget *iface)
 937 {
 938     return 1;
 939 }
 940
 941 static HRESULT WINAPI StaticWidget_GetTypeInfoCount(IStaticWidget *iface, UINT *pctinfo)
 942 {
 943     ok(0, "unexpected call\n");
 944     return E_NOTIMPL;
 945 }
 946
 947 static HRESULT WINAPI StaticWidget_GetTypeInfo(IStaticWidget *iface, UINT iTInfo, LCID lcid,
 948         ITypeInfo **ppTInfo)
 949 {
 950     ok(0, "unexpected call\n");
 951     return E_NOTIMPL;
 952 }
 953
 954 static HRESULT WINAPI StaticWidget_GetIDsOfNames(IStaticWidget *iface, REFIID riid, LPOLESTR *rgszNames,
 955         UINT cNames, LCID lcid, DISPID *rgDispId)
 956 {
 957     ok(0, "unexpected call\n");
 958     return E_NOTIMPL;
 959 }
 960
 961 static HRESULT WINAPI StaticWidget_Invoke(IStaticWidget *iface, DISPID dispIdMember, REFIID riid,
 962         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 963          UINT *puArgErr)
 964 {
 965     ok(0, "unexpected call\n");
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI StaticWidget_TestDual(IStaticWidget *iface, ItestDual *p)
 970 {
 971     trace("TestDual()\n");
 972     ok(p == &TestDual, "wrong ItestDual\n");
 973     return S_OK;
 974 }
 975
 976 static HRESULT WINAPI StaticWidget_TestSecondIface(IStaticWidget *iface, ITestSecondIface *p)
 977 {
 978     trace("TestSecondIface()\n");
 979     ok(p == &TestSecondIface, "wrong ItestSecondIface\n");
 980     return S_OK;
 981 }
 982
 983 static const IStaticWidgetVtbl StaticWidgetVtbl = {
 984     StaticWidget_QueryInterface,
 985     StaticWidget_AddRef,
 986     StaticWidget_Release,
 987     StaticWidget_GetTypeInfoCount,
 988     StaticWidget_GetTypeInfo,
 989     StaticWidget_GetIDsOfNames,
 990     StaticWidget_Invoke,
 991     StaticWidget_TestDual,
 992     StaticWidget_TestSecondIface
 993 };
 994
 995 static IStaticWidget StaticWidget = { &StaticWidgetVtbl };
 996
 997 typedef struct KindaEnum
 998 {
 999     IKindaEnumWidget IKindaEnumWidget_iface;
1000     LONG refs;
1001 } KindaEnum;
1002
1003 static inline KindaEnum *impl_from_IKindaEnumWidget(IKindaEnumWidget *iface)
1004 {
1005     return CONTAINING_RECORD(iface, KindaEnum, IKindaEnumWidget_iface);
1006 }
1007
1008 static HRESULT register_current_module_typelib(void)
1009 {
1010     WCHAR path[MAX_PATH];
1011     CHAR pathA[MAX_PATH];
1012     HRESULT hr;
1013     ITypeLib *typelib;
1014
1015     GetModuleFileNameA(NULL, pathA, MAX_PATH);
1016     MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
1017
1018     hr = LoadTypeLib(path, &typelib);
1019     if (SUCCEEDED(hr))
1020     {
1021         hr = RegisterTypeLib(typelib, path, NULL);
1022         ITypeLib_Release(typelib);
1023     }
1024     return hr;
1025 }
1026
1027 static ITypeInfo *get_type_info(REFIID riid)
1028 {
1029     ITypeInfo *pTypeInfo;
1030     ITypeLib *pTypeLib;
1031     HRESULT hr;
1032
1033     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1034     ok_ole_success(hr, LoadRegTypeLib);
1035     if (FAILED(hr))
1036         return NULL;
1037
1038     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
1039     ITypeLib_Release(pTypeLib);
1040     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1041     if (FAILED(hr))
1042         return NULL;
1043
1044     return pTypeInfo;
1045 }
1046
1047 static IWidget *Widget_Create(void)
1048 {
1049     Widget *This;
1050     ITypeInfo *pTypeInfo;
1051     HRESULT hr = E_FAIL;
1052
1053     pTypeInfo = get_type_info(&IID_IWidget);
1054     if(!pTypeInfo)
1055         return NULL;
1056
1057     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1058     This->IWidget_iface.lpVtbl = &Widget_VTable;
1059     This->refs = 1;
1060     This->pDispatchUnknown = NULL;
1061
1062     hr = CreateStdDispatch((IUnknown *)&This->IWidget_iface, This, pTypeInfo,
1063                            &This->pDispatchUnknown);
1064     ok_ole_success(hr, CreateStdDispatch);
1065     ITypeInfo_Release(pTypeInfo);
1066
1067     if (SUCCEEDED(hr))
1068         return &This->IWidget_iface;
1069     else
1070     {
1071         HeapFree(GetProcessHeap(), 0, This);
1072         return NULL;
1073     }
1074 }
1075
1076 static HRESULT WINAPI KindaEnum_QueryInterface(
1077     IKindaEnumWidget *iface,
1078     /* [in] */ REFIID riid,
1079     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
1080 {
1081     if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
1082     {
1083         IKindaEnumWidget_AddRef(iface);
1084         *ppvObject = iface;
1085         return S_OK;
1086     }
1087     else
1088     {
1089         *ppvObject = NULL;
1090         return E_NOINTERFACE;
1091     }
1092 }
1093
1094 static ULONG WINAPI KindaEnum_AddRef(
1095     IKindaEnumWidget *iface)
1096 {
1097     KindaEnum *This = impl_from_IKindaEnumWidget(iface);
1098
1099     return InterlockedIncrement(&This->refs);
1100 }
1101
1102 static ULONG WINAPI KindaEnum_Release(
1103     IKindaEnumWidget *iface)
1104 {
1105     KindaEnum *This = impl_from_IKindaEnumWidget(iface);
1106     ULONG refs = InterlockedDecrement(&This->refs);
1107     if (!refs)
1108     {
1109         memset(This, 0xcc, sizeof(*This));
1110         HeapFree(GetProcessHeap(), 0, This);
1111         trace("KindaEnumWidget destroyed!\n");
1112     }
1113
1114     return refs;
1115 }
1116
1117 static HRESULT WINAPI KindaEnum_Next(
1118     IKindaEnumWidget *iface,
1119     /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
1120 {
1121     *widget = Widget_Create();
1122     if (*widget)
1123         return S_OK;
1124     else
1125         return E_OUTOFMEMORY;
1126 }
1127
1128 static HRESULT WINAPI KindaEnum_Count(
1129     IKindaEnumWidget *iface,
1130     /* [out] */ ULONG __RPC_FAR *count)
1131 {
1132     return E_NOTIMPL;
1133 }
1134
1135 static HRESULT WINAPI KindaEnum_Reset(
1136     IKindaEnumWidget *iface)
1137 {
1138     return E_NOTIMPL;
1139 }
1140
1141 static HRESULT WINAPI KindaEnum_Clone(
1142     IKindaEnumWidget *iface,
1143     /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
1144 {
1145     return E_NOTIMPL;
1146 }
1147
1148 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
1149 {
1150     KindaEnum_QueryInterface,
1151     KindaEnum_AddRef,
1152     KindaEnum_Release,
1153     KindaEnum_Next,
1154     KindaEnum_Count,
1155     KindaEnum_Reset,
1156     KindaEnum_Clone
1157 };
1158
1159 static IKindaEnumWidget *KindaEnumWidget_Create(void)
1160 {
1161     KindaEnum *This;
1162
1163     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1164     if (!This) return NULL;
1165     This->IKindaEnumWidget_iface.lpVtbl = &KindaEnumWidget_VTable;
1166     This->refs = 1;
1167     return &This->IKindaEnumWidget_iface;
1168 }
1169
1170 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
1171 {
1172     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
1173     {
1174         *(INonOleAutomation **)ppv = iface;
1175         return S_OK;
1176     }
1177     *ppv = NULL;
1178     return E_NOINTERFACE;
1179 }
1180
1181 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
1182 {
1183     return 2;
1184 }
1185
1186 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
1187 {
1188     return 1;
1189 }
1190
1191 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
1192 {
1193     static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
1194     return SysAllocString(wszTestString);
1195 }
1196
1197 static HRESULT WINAPI NonOleAutomation_Error(INonOleAutomation *iface)
1198 {
1199     return E_NOTIMPL;
1200 }
1201
1202 static INonOleAutomationVtbl NonOleAutomation_VTable =
1203 {
1204     NonOleAutomation_QueryInterface,
1205     NonOleAutomation_AddRef,
1206     NonOleAutomation_Release,
1207     NonOleAutomation_BstrRet,
1208     NonOleAutomation_Error
1209 };
1210
1211 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
1212
1213 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
1214 {
1215     ITypeLib *pTypeLib;
1216     HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1217     ok_ole_success(hr, LoadRegTypeLib);
1218     if (SUCCEEDED(hr))
1219     {
1220         ITypeInfo *pTypeInfo;
1221         hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
1222         ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1223         ITypeLib_Release(pTypeLib);
1224         return pTypeInfo;
1225     }
1226     return NULL;
1227 }
1228
1229 static void test_typelibmarshal(void)
1230 {
1231     static const WCHAR szCat[] = { 'C','a','t',0 };
1232     static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
1233     static const WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
1234     HRESULT hr;
1235     IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
1236     IWidget *pWidget;
1237     IStream *pStream;
1238     IDispatch *pDispatch;
1239     static const LARGE_INTEGER ullZero;
1240     EXCEPINFO excepinfo;
1241     VARIANT varresult;
1242     DISPID dispidNamed = DISPID_PROPERTYPUT;
1243     DISPPARAMS dispparams;
1244     VARIANTARG vararg[4];
1245     STATE the_state;
1246     HANDLE thread;
1247     DWORD tid;
1248     BSTR bstr;
1249     ITypeInfo *pTypeInfo;
1250     MYSTRUCT mystruct;
1251     MYSTRUCT mystructArray[5];
1252     UINT uval;
1253
1254     ok(pKEW != NULL, "Widget creation failed\n");
1255
1256     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1257     ok_ole_success(hr, CreateStreamOnHGlobal);
1258     tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
1259     IKindaEnumWidget_Release(pKEW);
1260
1261     IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1262     hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
1263     ok_ole_success(hr, CoUnmarshalInterface);
1264     IStream_Release(pStream);
1265
1266     hr = IKindaEnumWidget_Next(pKEW, &pWidget);
1267     ok_ole_success(hr, IKindaEnumWidget_Next);
1268
1269     IKindaEnumWidget_Release(pKEW);
1270
1271     /* call GetTypeInfoCount (direct) */
1272     hr = IWidget_GetTypeInfoCount(pWidget, &uval);
1273     ok_ole_success(hr, IWidget_GetTypeInfoCount);
1274     hr = IWidget_GetTypeInfoCount(pWidget, &uval);
1275     ok_ole_success(hr, IWidget_GetTypeInfoCount);
1276
1277     hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
1278     ok_ole_success(hr, IWidget_QueryInterface);
1279
1280     /* call put_Name */
1281     VariantInit(&vararg[0]);
1282     dispparams.cNamedArgs = 1;
1283     dispparams.rgdispidNamedArgs = &dispidNamed;
1284     dispparams.cArgs = 1;
1285     dispparams.rgvarg = vararg;
1286     VariantInit(&varresult);
1287     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1288     ok_ole_success(hr, IDispatch_Invoke);
1289     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1290         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1291         excepinfo.wCode, excepinfo.scode);
1292     VariantClear(&varresult);
1293
1294     /* call put_Name (direct) */
1295     bstr = SysAllocString(szSuperman);
1296     hr = IWidget_put_Name(pWidget, bstr);
1297     ok_ole_success(hr, IWidget_put_Name);
1298     SysFreeString(bstr);
1299
1300     /* call get_Name */
1301     dispparams.cNamedArgs = 0;
1302     dispparams.rgdispidNamedArgs = NULL;
1303     dispparams.cArgs = 0;
1304     dispparams.rgvarg = NULL;
1305     VariantInit(&varresult);
1306     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1307     ok_ole_success(hr, IDispatch_Invoke);
1308     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1309         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1310         excepinfo.wCode, excepinfo.scode);
1311     trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1312     VariantClear(&varresult);
1313
1314     /* call get_Name (direct) */
1315     bstr = (void *)0xdeadbeef;
1316     hr = IWidget_get_Name(pWidget, &bstr);
1317     ok_ole_success(hr, IWidget_get_Name);
1318     ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
1319     SysFreeString(bstr);
1320
1321     /* call DoSomething */
1322     VariantInit(&vararg[0]);
1323     VariantInit(&vararg[1]);
1324     V_VT(&vararg[1]) = VT_R8;
1325     V_R8(&vararg[1]) = 3.141;
1326     dispparams.cNamedArgs = 0;
1327     dispparams.cArgs = 2;
1328     dispparams.rgdispidNamedArgs = NULL;
1329     dispparams.rgvarg = vararg;
1330     VariantInit(&varresult);
1331     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1332     ok_ole_success(hr, IDispatch_Invoke);
1333     ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1334     VariantClear(&varresult);
1335
1336     /* call get_State */
1337     dispparams.cNamedArgs = 0;
1338     dispparams.cArgs = 0;
1339     dispparams.rgdispidNamedArgs = NULL;
1340     dispparams.rgvarg = NULL;
1341     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1342     ok_ole_success(hr, IDispatch_Invoke);
1343     ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
1344
1345     /* call get_State (direct) */
1346     hr = IWidget_get_State(pWidget, &the_state);
1347     ok_ole_success(hr, IWidget_get_state);
1348     ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
1349
1350     /* call put_State */
1351     the_state = STATE_WIDGETIFIED;
1352     VariantInit(&vararg[0]);
1353     V_VT(&vararg[0]) = VT_BYREF|VT_I4;
1354     V_I4REF(&vararg[0]) = (int *)&the_state;
1355     dispparams.cNamedArgs = 1;
1356     dispparams.cArgs = 1;
1357     dispparams.rgdispidNamedArgs = &dispidNamed;
1358     dispparams.rgvarg = vararg;
1359     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1360     ok_ole_success(hr, IDispatch_Invoke);
1361
1362     /* call Map */
1363     bstr = SysAllocString(szTestTest);
1364     VariantInit(&vararg[0]);
1365     V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
1366     V_BSTRREF(&vararg[0]) = &bstr;
1367     dispparams.cNamedArgs = 0;
1368     dispparams.cArgs = 1;
1369     dispparams.rgdispidNamedArgs = NULL;
1370     dispparams.rgvarg = vararg;
1371     VariantInit(&varresult);
1372     hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1373     ok_ole_success(hr, IDispatch_Invoke);
1374     ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
1375     ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1376     VariantClear(&varresult);
1377     SysFreeString(bstr);
1378
1379     /* call SetOleColor with large negative VT_I4 param */
1380     VariantInit(&vararg[0]);
1381     V_VT(&vararg[0]) = VT_I4;
1382     V_I4(&vararg[0]) = 0x80000005;
1383     dispparams.cNamedArgs = 0;
1384     dispparams.cArgs = 1;
1385     dispparams.rgdispidNamedArgs = NULL;
1386     dispparams.rgvarg = vararg;
1387     hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1388     ok_ole_success(hr, IDispatch_Invoke);
1389
1390     /* call GetOleColor */
1391     dispparams.cNamedArgs = 0;
1392     dispparams.cArgs = 0;
1393     dispparams.rgdispidNamedArgs = NULL;
1394     dispparams.rgvarg = NULL;
1395     VariantInit(&varresult);
1396     hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1397     ok_ole_success(hr, IDispatch_Invoke);
1398     VariantClear(&varresult);
1399
1400     /* call StructArgs (direct) */
1401     mystruct = MYSTRUCT_BYPTR;
1402     memcpy(mystructArray, MYSTRUCT_ARRAY, sizeof(mystructArray));
1403     hr = IWidget_StructArgs(pWidget, MYSTRUCT_BYVAL, &mystruct, mystructArray);
1404     ok_ole_success(hr, IWidget_StructArgs);
1405
1406     /* call Clone */
1407     dispparams.cNamedArgs = 0;
1408     dispparams.cArgs = 0;
1409     dispparams.rgdispidNamedArgs = NULL;
1410     dispparams.rgvarg = NULL;
1411     VariantInit(&varresult);
1412     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1413     ok_ole_success(hr, IDispatch_Invoke);
1414     ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1415     VariantClear(&varresult);
1416
1417     /* call CloneInterface */
1418     dispparams.cNamedArgs = 0;
1419     dispparams.cArgs = 0;
1420     dispparams.rgdispidNamedArgs = NULL;
1421     dispparams.rgvarg = NULL;
1422     VariantInit(&varresult);
1423     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1424     ok_ole_success(hr, IDispatch_Invoke);
1425     ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1426     VariantClear(&varresult);
1427
1428     /* call CloneDispatch with automatic value getting */
1429     V_VT(&vararg[0]) = VT_I2;
1430     V_I2(&vararg[0]) = 1;
1431     dispparams.cNamedArgs = 0;
1432     dispparams.rgdispidNamedArgs = NULL;
1433     dispparams.cArgs = 1;
1434     dispparams.rgvarg = vararg;
1435     VariantInit(&varresult);
1436     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1437     ok_ole_success(hr, IDispatch_Invoke);
1438
1439     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1440         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1441         excepinfo.wCode, excepinfo.scode);
1442
1443     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1444     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1445     VariantClear(&varresult);
1446
1447     /* call CloneCoclass */
1448     dispparams.cNamedArgs = 0;
1449     dispparams.cArgs = 0;
1450     dispparams.rgdispidNamedArgs = NULL;
1451     dispparams.rgvarg = NULL;
1452     VariantInit(&varresult);
1453     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1454     ok_ole_success(hr, IDispatch_Invoke);
1455
1456     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1457        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1458        excepinfo.wCode, excepinfo.scode);
1459
1460     ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
1461     ok(!V_DISPATCH(&varresult), "V_DISPATCH(&varresult) should be NULL instead of %p\n", V_DISPATCH(&varresult));
1462     VariantClear(&varresult);
1463
1464     /* call Value with a VT_VARIANT|VT_BYREF type */
1465     V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
1466     V_VARIANTREF(&vararg[0]) = &vararg[1];
1467     V_VT(&vararg[1]) = VT_I2;
1468     V_I2(&vararg[1]) = 1;
1469     dispparams.cNamedArgs = 0;
1470     dispparams.rgdispidNamedArgs = NULL;
1471     dispparams.cArgs = 1;
1472     dispparams.rgvarg = vararg;
1473     VariantInit(&varresult);
1474     hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1475     ok_ole_success(hr, IDispatch_Invoke);
1476
1477     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1478         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1479         excepinfo.wCode, excepinfo.scode);
1480
1481     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1482     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1483     VariantClear(&varresult);
1484
1485     /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1486      * handling of void return types */
1487     /* use a big type to ensure that the variant was properly copied into the
1488      * destination function's args */
1489     V_VT(&vararg[0]) = VT_CY;
1490     S(V_CY(&vararg[0])).Hi = 0xdababe;
1491     S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
1492     dispparams.cNamedArgs = 0;
1493     dispparams.cArgs = 1;
1494     dispparams.rgdispidNamedArgs = NULL;
1495     dispparams.rgvarg = vararg;
1496     VariantInit(&varresult);
1497     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1498     ok_ole_success(hr, IDispatch_Invoke);
1499     VariantClear(&varresult);
1500
1501     /* call VariantCArray - test marshaling of variant arrays */
1502     V_VT(&vararg[0]) = VT_I4;
1503     V_I4(&vararg[0]) = 1;
1504     V_VT(&vararg[1]) = VT_I4;
1505     V_I4(&vararg[1]) = 2;
1506     hr = IWidget_VariantCArray(pWidget, 2, vararg);
1507     ok_ole_success(hr, IWidget_VariantCArray);
1508     todo_wine
1509     ok(V_VT(&vararg[0]) == VT_I4 && V_I4(&vararg[0]) == 2, "vararg[0] = %d[%d]\n", V_VT(&vararg[0]), V_I4(&vararg[0]));
1510     todo_wine
1511     ok(V_VT(&vararg[1]) == VT_I4 && V_I4(&vararg[1]) == 3, "vararg[1] = %d[%d]\n", V_VT(&vararg[1]), V_I4(&vararg[1]));
1512
1513     /* call VarArg */
1514     VariantInit(&vararg[3]);
1515     V_VT(&vararg[3]) = VT_I4;
1516     V_I4(&vararg[3]) = 3;
1517     VariantInit(&vararg[2]);
1518     V_VT(&vararg[2]) = VT_I4;
1519     V_I4(&vararg[2]) = 0;
1520     VariantInit(&vararg[1]);
1521     V_VT(&vararg[1]) = VT_I4;
1522     V_I4(&vararg[1]) = 1;
1523     VariantInit(&vararg[0]);
1524     V_VT(&vararg[0]) = VT_I4;
1525     V_I4(&vararg[0]) = 2;
1526     dispparams.cNamedArgs = 0;
1527     dispparams.cArgs = 4;
1528     dispparams.rgdispidNamedArgs = NULL;
1529     dispparams.rgvarg = vararg;
1530     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1531     ok_ole_success(hr, IDispatch_Invoke);
1532
1533     /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1534     dispidNamed = 0;
1535     dispparams.cNamedArgs = 1;
1536     dispparams.rgdispidNamedArgs = &dispidNamed;
1537     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1538     ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
1539     dispidNamed = DISPID_PROPERTYPUT;
1540
1541     /* call VarArg_Run */
1542     VariantInit(&vararg[1]);
1543     V_VT(&vararg[1]) = VT_BSTR;
1544     V_BSTR(&vararg[1]) = SysAllocString(szCat);
1545     VariantInit(&vararg[0]);
1546     V_VT(&vararg[0]) = VT_BSTR;
1547     V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
1548     dispparams.cNamedArgs = 0;
1549     dispparams.cArgs = 2;
1550     dispparams.rgdispidNamedArgs = NULL;
1551     dispparams.rgvarg = vararg;
1552     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1553     ok_ole_success(hr, IDispatch_Invoke);
1554     SysFreeString(V_BSTR(&vararg[1]));
1555     SysFreeString(V_BSTR(&vararg[0]));
1556
1557     /* call Error */
1558     dispparams.cNamedArgs = 0;
1559     dispparams.cArgs = 0;
1560     dispparams.rgdispidNamedArgs = NULL;
1561     dispparams.rgvarg = NULL;
1562     VariantInit(&varresult);
1563     hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1564     ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1565     ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1566         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1567         excepinfo.wCode, excepinfo.scode);
1568     VariantClear(&varresult);
1569
1570     /* call BstrRet */
1571     pTypeInfo = NonOleAutomation_GetTypeInfo();
1572     dispparams.cNamedArgs = 0;
1573     dispparams.cArgs = 0;
1574     dispparams.rgdispidNamedArgs = NULL;
1575     dispparams.rgvarg = NULL;
1576     VariantInit(&varresult);
1577     hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1578     ok_ole_success(hr, ITypeInfo_Invoke);
1579     ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
1580     ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
1581
1582     VariantClear(&varresult);
1583
1584     dispparams.cNamedArgs = 0;
1585     dispparams.cArgs = 0;
1586     dispparams.rgdispidNamedArgs = NULL;
1587     dispparams.rgvarg = NULL;
1588     hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_ERROR, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1589     ok(hr == DISP_E_EXCEPTION, "ITypeInfo_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1590     ok(V_VT(&varresult) == VT_EMPTY, "V_VT(&varresult) should be VT_EMPTY instead of %d\n", V_VT(&varresult));
1591     ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1592         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1593         excepinfo.wCode, excepinfo.scode);
1594     VariantClear(&varresult);
1595
1596     ITypeInfo_Release(pTypeInfo);
1597
1598     /* tests call put_Name without named arg */
1599     VariantInit(&vararg[0]);
1600     dispparams.cNamedArgs = 0;
1601     dispparams.rgdispidNamedArgs = NULL;
1602     dispparams.cArgs = 1;
1603     dispparams.rgvarg = vararg;
1604     VariantInit(&varresult);
1605     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1606     ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
1607     VariantClear(&varresult);
1608
1609     /* tests param type that cannot be coerced */
1610     VariantInit(&vararg[0]);
1611     V_VT(&vararg[0]) = VT_UNKNOWN;
1612     V_UNKNOWN(&vararg[0]) = NULL;
1613     dispparams.cNamedArgs = 1;
1614     dispparams.rgdispidNamedArgs = &dispidNamed;
1615     dispparams.cArgs = 1;
1616     dispparams.rgvarg = vararg;
1617     VariantInit(&varresult);
1618     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1619     ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1620     VariantClear(&varresult);
1621
1622     /* tests bad param type */
1623     VariantInit(&vararg[0]);
1624     V_VT(&vararg[0]) = VT_CLSID;
1625     V_BYREF(&vararg[0]) = NULL;
1626     dispparams.cNamedArgs = 1;
1627     dispparams.rgdispidNamedArgs = &dispidNamed;
1628     dispparams.cArgs = 1;
1629     dispparams.rgvarg = vararg;
1630     VariantInit(&varresult);
1631     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1632     ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1633     VariantClear(&varresult);
1634
1635     /* tests too small param count */
1636     dispparams.cNamedArgs = 0;
1637     dispparams.rgdispidNamedArgs = NULL;
1638     dispparams.cArgs = 0;
1639     dispparams.rgvarg = NULL;
1640     VariantInit(&varresult);
1641     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1642     ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1643     VariantClear(&varresult);
1644
1645     /* tests propget function with large param count */
1646     VariantInit(&vararg[0]);
1647     V_VT(&vararg[0]) = VT_BSTR;
1648     V_BSTR(&vararg[0]) = NULL;
1649     V_VT(&vararg[1]) = VT_I4;
1650     V_I4(&vararg[1]) = 1;
1651     dispparams.cNamedArgs = 0;
1652     dispparams.cArgs = 2;
1653     dispparams.rgdispidNamedArgs = NULL;
1654     dispparams.rgvarg = vararg;
1655     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1656     ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1657
1658     /* test propput with lcid */
1659
1660     /* the lcid passed to the function is the first lcid in the typelib header.
1661        Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1662     VariantInit(&vararg[0]);
1663     V_VT(&vararg[0]) = VT_I4;
1664     V_I4(&vararg[0]) = 0xcafe;
1665     dispparams.cNamedArgs = 1;
1666     dispparams.rgdispidNamedArgs = &dispidNamed;
1667     dispparams.cArgs = 1;
1668     dispparams.rgvarg = vararg;
1669     VariantInit(&varresult);
1670     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1671     ok_ole_success(hr, ITypeInfo_Invoke);
1672     VariantClear(&varresult);
1673
1674     /* test propget with lcid */
1675     dispparams.cNamedArgs = 0;
1676     dispparams.cArgs = 0;
1677     dispparams.rgvarg = NULL;
1678     dispparams.rgdispidNamedArgs = NULL;
1679     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1680     ok_ole_success(hr, ITypeInfo_Invoke);
1681     ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1682     ok(V_I4(&varresult) == 0x409, "got %x\n", V_I4(&varresult));
1683     VariantClear(&varresult);
1684
1685     /* test propget of INT value */
1686     dispparams.cNamedArgs = 0;
1687     dispparams.cArgs = 0;
1688     dispparams.rgvarg = NULL;
1689     dispparams.rgdispidNamedArgs = NULL;
1690     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_INT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1691     ok_ole_success(hr, ITypeInfo_Invoke);
1692     ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1693     ok(V_I4(&varresult) == -13, "got %x\n", V_I4(&varresult));
1694     VariantClear(&varresult);
1695
1696     /* test propget of INT value */
1697     dispparams.cNamedArgs = 0;
1698     dispparams.cArgs = 0;
1699     dispparams.rgvarg = NULL;
1700     dispparams.rgdispidNamedArgs = NULL;
1701     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_UINT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1702     ok_ole_success(hr, ITypeInfo_Invoke);
1703     ok(V_VT(&varresult) == VT_UI4, "got %x\n", V_VT(&varresult));
1704     ok(V_UI4(&varresult) == 42, "got %x\n", V_UI4(&varresult));
1705     VariantClear(&varresult);
1706
1707     /* test byref marshalling */
1708     uval = 666;
1709     VariantInit(&vararg[0]);
1710     V_VT(&vararg[0]) = VT_UI4|VT_BYREF;
1711     V_UI4REF(&vararg[0]) = &uval;
1712     dispparams.cNamedArgs = 0;
1713     dispparams.cArgs = 1;
1714     dispparams.rgvarg = vararg;
1715     dispparams.rgdispidNamedArgs = NULL;
1716     hr = IDispatch_Invoke(pDispatch, DISPID_TM_BYREF_UINT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1717     ok_ole_success(hr, ITypeInfo_Invoke);
1718     ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1719     ok(V_VT(&vararg[0]) == (VT_UI4|VT_BYREF), "arg VT not unmarshalled correctly: %x\n", V_VT(&vararg[0]));
1720     ok(V_UI4REF(&vararg[0]) == &uval, "Byref pointer not preserved: %p/%p\n", &uval, V_UI4REF(&vararg[0]));
1721     ok(*V_UI4REF(&vararg[0]) == 42, "Expected 42 to be returned instead of %u\n", *V_UI4REF(&vararg[0]));
1722     VariantClear(&varresult);
1723     VariantClear(&vararg[0]);
1724
1725     /* test propput with optional argument. */
1726     VariantInit(&vararg[0]);
1727     V_VT(&vararg[0]) = VT_I4;
1728     V_I4(&vararg[0]) = 0xcafe;
1729     dispparams.cNamedArgs = 1;
1730     dispparams.rgdispidNamedArgs = &dispidNamed;
1731     dispparams.cArgs = 1;
1732     dispparams.rgvarg = vararg;
1733     VariantInit(&varresult);
1734     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_OPT_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1735     ok_ole_success(hr, ITypeInfo_Invoke);
1736     VariantClear(&varresult);
1737
1738     /* test propput with required argument. */
1739     VariantInit(&vararg[0]);
1740     VariantInit(&vararg[1]);
1741     V_VT(&vararg[0]) = VT_I4;
1742     V_I4(&vararg[0]) = 0x1234;
1743     V_VT(&vararg[1]) = VT_I4;
1744     V_I4(&vararg[1]) = 0x5678;
1745     dispparams.cNamedArgs = 1;
1746     dispparams.rgdispidNamedArgs = &dispidNamed;
1747     dispparams.cArgs = 2;
1748     dispparams.rgvarg = vararg;
1749     VariantInit(&varresult);
1750     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_REQ_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1751     ok_ole_success(hr, ITypeInfo_Invoke);
1752     VariantClear(&varresult);
1753
1754     /* restricted member */
1755     dispparams.cNamedArgs = 0;
1756     dispparams.rgdispidNamedArgs = NULL;
1757     dispparams.cArgs = 0;
1758     dispparams.rgvarg = NULL;
1759     VariantInit(&varresult);
1760     hr = IDispatch_Invoke(pDispatch, DISPID_TM_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1761     ok( hr == DISP_E_MEMBERNOTFOUND, "got %08x\n", hr );
1762     VariantClear(&varresult);
1763
1764     /* restricted member with -ve memid (not restricted) */
1765     dispparams.cNamedArgs = 0;
1766     dispparams.rgdispidNamedArgs = NULL;
1767     dispparams.cArgs = 0;
1768     dispparams.rgvarg = NULL;
1769     VariantInit(&varresult);
1770     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NEG_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1771     ok( hr == S_OK, "got %08x\n", hr );
1772     ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1773     ok(V_I4(&varresult) == DISPID_TM_NEG_RESTRICTED, "got %x\n", V_I4(&varresult));
1774     VariantClear(&varresult);
1775
1776     IDispatch_Release(pDispatch);
1777     IWidget_Release(pWidget);
1778
1779     trace("calling end_host_object\n");
1780     end_host_object(tid, thread);
1781 }
1782
1783 static void test_DispCallFunc(void)
1784 {
1785     static const WCHAR szEmpty[] = { 0 };
1786     VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1787     VARIANTARG vararg[4];
1788     VARIANTARG varref;
1789     VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1790     VARIANTARG varresult;
1791     HRESULT hr;
1792     IWidget *pWidget = Widget_Create();
1793     V_VT(&vararg[0]) = VT_R8;
1794     V_R8(&vararg[0]) = 3.141;
1795     V_VT(&vararg[1]) = VT_BSTR;
1796     V_BSTRREF(&vararg[1]) = CoTaskMemAlloc(sizeof(BSTR));
1797     V_VT(&vararg[2]) = VT_BSTR;
1798     V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1799     V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1800     V_VARIANTREF(&vararg[3]) = &varref;
1801     V_VT(&varref) = VT_ERROR;
1802     V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1803     VariantInit(&varresult);
1804     hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1805     ok_ole_success(hr, DispCallFunc);
1806     VariantClear(&varresult);
1807     SysFreeString(*V_BSTRREF(&vararg[1]));
1808     CoTaskMemFree(V_BSTRREF(&vararg[1]));
1809     VariantClear(&vararg[2]);
1810     IWidget_Release(pWidget);
1811 }
1812
1813 static void test_StaticWidget(void)
1814 {
1815     ITypeInfo *type_info;
1816     DISPPARAMS dispparams;
1817     VARIANTARG vararg[4];
1818     EXCEPINFO excepinfo;
1819     VARIANT varresult;
1820     HRESULT hr;
1821
1822     type_info = get_type_info(&IID_IStaticWidget);
1823
1824     /* call TestDual */
1825     dispparams.cNamedArgs = 0;
1826     dispparams.cArgs = 1;
1827     dispparams.rgdispidNamedArgs = NULL;
1828     dispparams.rgvarg = vararg;
1829     V_VT(vararg) = VT_DISPATCH;
1830     V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1831     VariantInit(&varresult);
1832     hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
1833             &dispparams, &varresult, &excepinfo, NULL);
1834     ok_ole_success(hr, IDispatch_Invoke);
1835     ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1836     VariantClear(&varresult);
1837
1838     /* call TestSecondIface */
1839     dispparams.cNamedArgs = 0;
1840     dispparams.cArgs = 1;
1841     dispparams.rgdispidNamedArgs = NULL;
1842     dispparams.rgvarg = vararg;
1843     V_VT(vararg) = VT_DISPATCH;
1844     V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1845     VariantInit(&varresult);
1846     hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTSECONDIFACE, DISPATCH_METHOD,
1847             &dispparams, &varresult, &excepinfo, NULL);
1848     ok_ole_success(hr, IDispatch_Invoke);
1849     ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1850     VariantClear(&varresult);
1851
1852     ITypeInfo_Release(type_info);
1853 }
1854
1855 static void test_libattr(void)
1856 {
1857     ITypeLib *pTypeLib;
1858     HRESULT hr;
1859     TLIBATTR *pattr;
1860
1861     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1862     ok_ole_success(hr, LoadRegTypeLib);
1863     if (FAILED(hr))
1864         return;
1865
1866     hr = ITypeLib_GetLibAttr(pTypeLib, &pattr);
1867     ok_ole_success(hr, GetLibAttr);
1868     if (SUCCEEDED(hr))
1869     {
1870         ok(pattr->lcid == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), "lcid %x\n", pattr->lcid);
1871
1872         ITypeLib_ReleaseTLibAttr(pTypeLib, pattr);
1873     }
1874
1875     ITypeLib_Release(pTypeLib);
1876 }
1877
1878 static void test_external_connection(void)
1879 {
1880     IStream *stream, *stream2;
1881     ITestSecondDisp *second;
1882     ItestDual *iface;
1883     HANDLE thread;
1884     DWORD tid;
1885     HRESULT hres;
1886
1887     static const LARGE_INTEGER zero;
1888
1889     trace("Testing IExternalConnection...\n");
1890
1891     external_connections = 0;
1892
1893     /* Marshaling an interface increases external connection count. */
1894     expect_last_release_closes = FALSE;
1895     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1896     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
1897     tid = start_host_object(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHLFLAGS_NORMAL, &thread);
1898     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1899
1900     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1901     hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
1902     ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
1903     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1904
1905     IStream_Release(stream);
1906     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1907
1908     /* Creating a stub for new iface causes new external connection. */
1909     hres = ItestDual_QueryInterface(iface, &IID_ITestSecondDisp, (void**)&second);
1910     ok(hres == S_OK, "Could not get ITestSecondDisp iface: %08x\n", hres);
1911     todo_wine
1912     ok(external_connections == 2, "external_connections = %d\n", external_connections);
1913
1914     ITestSecondDisp_Release(second);
1915     todo_wine
1916     ok(external_connections == 2, "external_connections = %d\n", external_connections);
1917
1918     expect_last_release_closes = TRUE;
1919     ItestDual_Release(iface);
1920     ok(external_connections == 0, "external_connections = %d\n", external_connections);
1921
1922     end_host_object(tid, thread);
1923
1924     /* A test with direct CoMarshalInterface call. */
1925     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1926     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
1927
1928     expect_last_release_closes = FALSE;
1929     hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1930     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
1931     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1932
1933     expect_last_release_closes = TRUE;
1934     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1935     hres = CoReleaseMarshalData(stream);
1936     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
1937     ok(external_connections == 0, "external_connections = %d\n", external_connections);
1938
1939     /* Two separated marshal data are still one external connection. */
1940     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream2);
1941     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
1942
1943     expect_last_release_closes = FALSE;
1944     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1945     hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1946     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
1947     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1948
1949     hres = CoMarshalInterface(stream2, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1950     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
1951     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1952
1953     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1954     hres = CoReleaseMarshalData(stream);
1955     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
1956     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1957
1958     expect_last_release_closes = TRUE;
1959     IStream_Seek(stream2, zero, STREAM_SEEK_SET, NULL);
1960     hres = CoReleaseMarshalData(stream2);
1961     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
1962     ok(external_connections == 0, "external_connections = %d\n", external_connections);
1963
1964     /* Weak table marshaling does not increment external connections */
1965     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1966     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
1967
1968     hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
1969     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
1970     ok(external_connections == 0, "external_connections = %d\n", external_connections);
1971
1972     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1973     hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
1974     ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
1975     ok(external_connections == 0, "external_connections = %d\n", external_connections);
1976     ItestDual_Release(iface);
1977
1978     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1979     hres = CoReleaseMarshalData(stream);
1980     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
1981     ok(external_connections == 0, "external_connections = %d\n", external_connections);
1982 }
1983
1984 START_TEST(tmarshal)
1985 {
1986     HRESULT hr;
1987     HANDLE hOleaut32 = GetModuleHandleA("oleaut32.dll");
1988     pVarAdd = (void*)GetProcAddress(hOleaut32, "VarAdd");
1989
1990     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1991
1992     hr = register_current_module_typelib();
1993     if (FAILED(hr))
1994     {
1995         CoUninitialize();
1996         win_skip("Registration of the test typelib failed, skipping tests\n");
1997         return;
1998     }
1999
2000     test_typelibmarshal();
2001     test_DispCallFunc();
2002     test_StaticWidget();
2003     test_libattr();
2004     test_external_connection();
2005
2006     hr = UnRegisterTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL,
2007                            sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
2008     ok_ole_success(hr, UnRegisterTypeLib);
2009
2010     CoUninitialize();
2011 }